66 #include "llvm/ADT/APFloat.h"
67 #include "llvm/ADT/APInt.h"
68 #include "llvm/ADT/APSInt.h"
69 #include "llvm/ADT/ArrayRef.h"
70 #include "llvm/ADT/DenseMap.h"
71 #include "llvm/ADT/FoldingSet.h"
72 #include "llvm/ADT/STLExtras.h"
73 #include "llvm/ADT/SmallBitVector.h"
74 #include "llvm/ADT/SmallPtrSet.h"
75 #include "llvm/ADT/SmallString.h"
76 #include "llvm/ADT/SmallVector.h"
77 #include "llvm/ADT/StringExtras.h"
78 #include "llvm/ADT/StringRef.h"
79 #include "llvm/ADT/StringSet.h"
80 #include "llvm/ADT/StringSwitch.h"
81 #include "llvm/Support/AtomicOrdering.h"
82 #include "llvm/Support/Casting.h"
83 #include "llvm/Support/Compiler.h"
84 #include "llvm/Support/ConvertUTF.h"
85 #include "llvm/Support/ErrorHandling.h"
86 #include "llvm/Support/Format.h"
87 #include "llvm/Support/Locale.h"
88 #include "llvm/Support/MathExtras.h"
89 #include "llvm/Support/SaveAndRestore.h"
90 #include "llvm/Support/raw_ostream.h"
91 #include "llvm/TargetParser/RISCVTargetParser.h"
92 #include "llvm/TargetParser/Triple.h"
106 using namespace clang;
107 using namespace sema;
113 unsigned ByteNo)
const {
127 unsigned MinArgCount) {
128 unsigned ArgCount = Call->getNumArgs();
129 if (ArgCount >= MinArgCount)
132 return S.
Diag(Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
133 << 0 << MinArgCount << ArgCount
134 << 0 << Call->getSourceRange();
141 unsigned ArgCount = Call->getNumArgs();
142 if (ArgCount <= MaxArgCount)
144 return S.
Diag(Call->getEndLoc(),
145 diag::err_typecheck_call_too_many_args_at_most)
146 << 0 << MaxArgCount << ArgCount
147 << 0 << Call->getSourceRange();
154 unsigned MaxArgCount) {
162 unsigned ArgCount = Call->getNumArgs();
163 if (ArgCount == DesiredArgCount)
168 assert(ArgCount > DesiredArgCount &&
"should have diagnosed this");
171 SourceRange Range(Call->getArg(DesiredArgCount)->getBeginLoc(),
172 Call->getArg(ArgCount - 1)->getEndLoc());
174 return S.
Diag(Range.getBegin(), diag::err_typecheck_call_too_many_args)
175 << 0 << DesiredArgCount << ArgCount
176 << 0 << Call->getArg(1)->getSourceRange();
180 if (
Value->isTypeDependent())
187 if (Result.isInvalid())
189 Value = Result.get();
224 S.
Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
232 auto *
Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
234 S.
Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
235 << Arg->getSourceRange();
269 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
300 bool IsBooleanAlignBuiltin =
ID == Builtin::BI__builtin_is_aligned;
302 auto IsValidIntegerType = [](
QualType Ty) {
303 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
310 if ((!SrcTy->
isPointerType() && !IsValidIntegerType(SrcTy)) ||
314 S.
Diag(Source->
getExprLoc(), diag::err_typecheck_expect_scalar_operand)
320 if (!IsValidIntegerType(AlignOp->
getType())) {
333 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
334 if (AlignValue < 1) {
335 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_too_small) << 1;
338 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
343 if (!AlignValue.isPowerOf2()) {
344 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_not_power_of_two);
347 if (AlignValue == 1) {
348 S.
Diag(AlignOp->
getExprLoc(), diag::warn_alignment_builtin_useless)
349 << IsBooleanAlignBuiltin;
377 std::pair<unsigned, const char *> Builtins[] = {
378 { Builtin::BI__builtin_add_overflow,
"ckd_add" },
379 { Builtin::BI__builtin_sub_overflow,
"ckd_sub" },
380 { Builtin::BI__builtin_mul_overflow,
"ckd_mul" },
383 bool CkdOperation = llvm::any_of(Builtins, [&](
const std::pair<
unsigned,
385 return BuiltinID ==
P.first && TheCall->
getExprLoc().isMacroID() &&
390 auto ValidCkdIntType = [](
QualType QT) {
393 if (
const auto *BT = QT.getCanonicalType()->getAs<
BuiltinType>())
394 return (BT->getKind() >= BuiltinType::Short &&
395 BT->getKind() <= BuiltinType::Int128) || (
396 BT->getKind() >= BuiltinType::UShort &&
397 BT->getKind() <= BuiltinType::UInt128) ||
398 BT->getKind() == BuiltinType::UChar ||
399 BT->getKind() == BuiltinType::SChar;
404 for (
unsigned I = 0; I < 2; ++I) {
410 bool IsValid = CkdOperation ? ValidCkdIntType(Ty) : Ty->
isIntegerType();
429 !PtrTy->getPointeeType()->isIntegerType() ||
430 (!ValidCkdIntType(PtrTy->getPointeeType()) && CkdOperation) ||
431 PtrTy->getPointeeType().isConstQualified()) {
433 diag::err_overflow_builtin_must_be_ptr_int)
441 if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
442 for (
unsigned I = 0; I < 3; ++I) {
443 const auto Arg = TheCall->
getArg(I);
446 if (Ty->isBitIntType() && Ty->isSignedIntegerType() &&
448 return S.
Diag(Arg->getBeginLoc(),
449 diag::err_overflow_builtin_bit_int_max_size)
458 struct BuiltinDumpStructGenerator {
467 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
468 Policy(S.Context.getPrintingPolicy()) {
472 Expr *makeOpaqueValueExpr(
Expr *Inner) {
475 Inner->getObjectKind(), Inner);
476 Actions.push_back(OVE);
480 Expr *getStringLiteral(llvm::StringRef Str) {
486 bool callPrintFunction(llvm::StringRef Format,
490 Args.reserve((TheCall->
getNumArgs() - 2) + 1 + Exprs.size());
492 Args.push_back(getStringLiteral(Format));
493 Args.insert(Args.end(), Exprs.begin(), Exprs.end());
509 Actions.push_back(RealCall.
get());
521 return getStringLiteral(
Indent);
525 return getStringLiteral(
T.getAsString(Policy));
529 llvm::raw_svector_ostream OS(Str);
534 switch (BT->getKind()) {
535 case BuiltinType::Bool:
538 case BuiltinType::Char_U:
539 case BuiltinType::UChar:
542 case BuiltinType::Char_S:
543 case BuiltinType::SChar:
561 Specifier.setPrecision(analyze_printf::OptionalAmount(32u));
582 Expr *IndentLit = getIndentString(
Depth);
584 if (IndentLit ? callPrintFunction(
"%s%s", {IndentLit, TypeLit})
585 : callPrintFunction(
"%s", {TypeLit}))
588 return dumpRecordValue(RD, E, IndentLit,
Depth);
601 Expr *RecordArg = makeOpaqueValueExpr(E);
604 if (callPrintFunction(
" {\n"))
608 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
609 for (
const auto &
Base : CXXRD->bases()) {
617 dumpUnnamedRecord(
Base.getType()->getAsRecordDecl(), BasePtr.
get(),
623 Expr *FieldIndentArg = getIndentString(
Depth + 1);
626 for (
auto *D : RD->
decls()) {
627 auto *IFD = dyn_cast<IndirectFieldDecl>(D);
628 auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
629 if (!FD || FD->isUnnamedBitField() || FD->isAnonymousStructOrUnion())
635 getStringLiteral(FD->getName())};
637 if (FD->isBitField()) {
641 FD->getBitWidthValue(S.
Context));
655 if (
Field.isInvalid())
658 auto *InnerRD = FD->getType()->getAsRecordDecl();
659 auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
660 if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
662 if (callPrintFunction(Format, Args) ||
663 dumpRecordValue(InnerRD,
Field.get(), FieldIndentArg,
Depth + 1))
667 if (appendFormatSpecifier(FD->getType(), Format)) {
669 Args.push_back(
Field.get());
679 Args.push_back(FieldAddr.
get());
682 if (callPrintFunction(Format, Args))
687 return RecordIndent ? callPrintFunction(
"%s}\n", RecordIndent)
688 : callPrintFunction(
"}\n");
691 Expr *buildWrapper() {
694 TheCall->
setType(Wrapper->getType());
715 diag::err_expected_struct_pointer_argument)
724 diag::err_incomplete_type))
733 switch (BT ? BT->getKind() : BuiltinType::Void) {
734 case BuiltinType::Dependent:
735 case BuiltinType::Overload:
736 case BuiltinType::BoundMember:
737 case BuiltinType::PseudoObject:
738 case BuiltinType::UnknownAny:
739 case BuiltinType::BuiltinFn:
745 diag::err_expected_callable_argument)
751 BuiltinDumpStructGenerator
Generator(S, TheCall);
757 Expr *PtrArg = PtrArgResult.
get();
761 if (
Generator.dumpUnnamedRecord(RD, PtrArg, 0))
776 if (Call->getStmtClass() != Stmt::CallExprClass) {
777 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
778 << Call->getSourceRange();
782 auto CE = cast<CallExpr>(Call);
783 if (CE->getCallee()->getType()->isBlockPointerType()) {
784 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
785 << Call->getSourceRange();
789 const Decl *TargetDecl = CE->getCalleeDecl();
790 if (
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
791 if (FD->getBuiltinID()) {
792 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
793 << Call->getSourceRange();
797 if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
798 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
799 << Call->getSourceRange();
807 S.
Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
821 BuiltinCall->
setType(CE->getType());
825 BuiltinCall->
setArg(1, ChainResult.
get());
832 class ScanfDiagnosticFormatHandler
836 using ComputeSizeFunction =
837 llvm::function_ref<std::optional<llvm::APSInt>(
unsigned)>;
841 using DiagnoseFunction =
842 llvm::function_ref<void(
unsigned,
unsigned,
unsigned)>;
844 ComputeSizeFunction ComputeSizeArgument;
845 DiagnoseFunction Diagnose;
848 ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,
849 DiagnoseFunction Diagnose)
850 : ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}
853 const char *StartSpecifier,
854 unsigned specifierLen)
override {
855 if (!FS.consumesDataArgument())
858 unsigned NulByte = 0;
859 switch ((FS.getConversionSpecifier().getKind())) {
872 analyze_format_string::OptionalAmount::HowSpecified::Constant)
877 std::optional<llvm::APSInt> DestSizeAPS =
878 ComputeSizeArgument(FS.getArgIndex());
882 unsigned DestSize = DestSizeAPS->getZExtValue();
884 if (DestSize < SourceSize)
885 Diagnose(FS.getArgIndex(), DestSize, SourceSize);
891 class EstimateSizeFormatHandler
896 bool IsKernelCompatible =
true;
899 EstimateSizeFormatHandler(StringRef Format)
900 :
Size(
std::
min(Format.find(0), Format.size()) +
904 const char *,
unsigned SpecifierLen,
907 const size_t FieldWidth = computeFieldWidth(FS);
908 const size_t Precision = computePrecision(FS);
911 switch (FS.getConversionSpecifier().getKind()) {
944 (Precision ? 1 + Precision
954 (Precision ? 1 + Precision : 0) +
964 (Precision ? 1 + Precision : 0) +
979 IsKernelCompatible =
false;
992 Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();
994 if (FS.hasAlternativeForm()) {
995 switch (FS.getConversionSpecifier().getKind()) {
1024 Size += (Precision ? 0 : 1);
1031 assert(SpecifierLen <= Size &&
"no underflow");
1032 Size -= SpecifierLen;
1036 size_t getSizeLowerBound()
const {
return Size; }
1037 bool isKernelCompatible()
const {
return IsKernelCompatible; }
1042 size_t FieldWidth = 0;
1050 size_t Precision = 0;
1055 switch (FS.getConversionSpecifier().getKind()) {
1097 StringRef &FormatStrRef,
size_t &StrLen,
1099 if (
const auto *Format = dyn_cast<StringLiteral>(FormatExpr);
1100 Format && (Format->isOrdinary() || Format->isUTF8())) {
1101 FormatStrRef = Format->getString();
1104 assert(
T &&
"String literal not of constant array type!");
1105 size_t TypeSize =
T->getZExtSize();
1107 StrLen =
std::min(
std::max(TypeSize,
size_t(1)) - 1, FormatStrRef.find(0));
1113 void Sema::checkFortifiedBuiltinMemoryFunction(
FunctionDecl *FD,
1116 isConstantEvaluatedContext())
1119 bool UseDABAttr =
false;
1122 const auto *DABAttr = FD->
getAttr<DiagnoseAsBuiltinAttr>();
1124 UseDecl = DABAttr->getFunction();
1125 assert(UseDecl &&
"Missing FunctionDecl in DiagnoseAsBuiltin attribute!");
1134 const TargetInfo &TI = getASTContext().getTargetInfo();
1137 auto TranslateIndex = [&](
unsigned Index) -> std::optional<unsigned> {
1144 unsigned DABIndices = DABAttr->argIndices_size();
1145 unsigned NewIndex = Index < DABIndices
1146 ? DABAttr->argIndices_begin()[Index]
1149 return std::nullopt;
1153 auto ComputeExplicitObjectSizeArgument =
1154 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1155 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1157 return std::nullopt;
1158 unsigned NewIndex = *IndexOptional;
1162 return std::nullopt;
1168 auto ComputeSizeArgument =
1169 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1175 if (Index < FD->getNumParams()) {
1176 if (
const auto *POS =
1178 BOSType = POS->getType();
1181 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1183 return std::nullopt;
1184 unsigned NewIndex = *IndexOptional;
1187 return std::nullopt;
1189 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1192 return std::nullopt;
1195 return llvm::APSInt::getUnsigned(Result).extOrTrunc(SizeTypeWidth);
1198 auto ComputeStrLenArgument =
1199 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1200 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1202 return std::nullopt;
1203 unsigned NewIndex = *IndexOptional;
1205 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1208 return std::nullopt;
1210 return llvm::APSInt::getUnsigned(Result + 1).extOrTrunc(SizeTypeWidth);
1213 std::optional<llvm::APSInt> SourceSize;
1214 std::optional<llvm::APSInt> DestinationSize;
1215 unsigned DiagID = 0;
1216 bool IsChkVariant =
false;
1218 auto GetFunctionName = [&]() {
1219 StringRef FunctionName = getASTContext().BuiltinInfo.getName(BuiltinID);
1224 FunctionName = FunctionName.drop_front(std::strlen(
"__builtin___"));
1225 FunctionName = FunctionName.drop_back(std::strlen(
"_chk"));
1227 FunctionName.consume_front(
"__builtin_");
1229 return FunctionName;
1232 switch (BuiltinID) {
1235 case Builtin::BI__builtin_strcpy:
1236 case Builtin::BIstrcpy: {
1237 DiagID = diag::warn_fortify_strlen_overflow;
1238 SourceSize = ComputeStrLenArgument(1);
1239 DestinationSize = ComputeSizeArgument(0);
1243 case Builtin::BI__builtin___strcpy_chk: {
1244 DiagID = diag::warn_fortify_strlen_overflow;
1245 SourceSize = ComputeStrLenArgument(1);
1246 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1247 IsChkVariant =
true;
1251 case Builtin::BIscanf:
1252 case Builtin::BIfscanf:
1253 case Builtin::BIsscanf: {
1254 unsigned FormatIndex = 1;
1255 unsigned DataIndex = 2;
1256 if (BuiltinID == Builtin::BIscanf) {
1261 const auto *FormatExpr =
1264 StringRef FormatStrRef;
1269 auto Diagnose = [&](
unsigned ArgIndex,
unsigned DestSize,
1270 unsigned SourceSize) {
1271 DiagID = diag::warn_fortify_scanf_overflow;
1272 unsigned Index = ArgIndex + DataIndex;
1273 StringRef FunctionName = GetFunctionName();
1275 PDiag(DiagID) << FunctionName << (Index + 1)
1276 << DestSize << SourceSize);
1279 auto ShiftedComputeSizeArgument = [&](
unsigned Index) {
1280 return ComputeSizeArgument(Index + DataIndex);
1282 ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument, Diagnose);
1283 const char *FormatBytes = FormatStrRef.data();
1285 FormatBytes + StrLen, getLangOpts(),
1294 case Builtin::BIsprintf:
1295 case Builtin::BI__builtin___sprintf_chk: {
1296 size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
1299 StringRef FormatStrRef;
1302 EstimateSizeFormatHandler H(FormatStrRef);
1303 const char *FormatBytes = FormatStrRef.data();
1305 H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
1307 DiagID = H.isKernelCompatible()
1308 ? diag::warn_format_overflow
1309 : diag::warn_format_overflow_non_kprintf;
1310 SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1311 .extOrTrunc(SizeTypeWidth);
1312 if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
1313 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1314 IsChkVariant =
true;
1316 DestinationSize = ComputeSizeArgument(0);
1323 case Builtin::BI__builtin___memcpy_chk:
1324 case Builtin::BI__builtin___memmove_chk:
1325 case Builtin::BI__builtin___memset_chk:
1326 case Builtin::BI__builtin___strlcat_chk:
1327 case Builtin::BI__builtin___strlcpy_chk:
1328 case Builtin::BI__builtin___strncat_chk:
1329 case Builtin::BI__builtin___strncpy_chk:
1330 case Builtin::BI__builtin___stpncpy_chk:
1331 case Builtin::BI__builtin___memccpy_chk:
1332 case Builtin::BI__builtin___mempcpy_chk: {
1333 DiagID = diag::warn_builtin_chk_overflow;
1334 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 2);
1336 ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1337 IsChkVariant =
true;
1341 case Builtin::BI__builtin___snprintf_chk:
1342 case Builtin::BI__builtin___vsnprintf_chk: {
1343 DiagID = diag::warn_builtin_chk_overflow;
1344 SourceSize = ComputeExplicitObjectSizeArgument(1);
1345 DestinationSize = ComputeExplicitObjectSizeArgument(3);
1346 IsChkVariant =
true;
1350 case Builtin::BIstrncat:
1351 case Builtin::BI__builtin_strncat:
1352 case Builtin::BIstrncpy:
1353 case Builtin::BI__builtin_strncpy:
1354 case Builtin::BIstpncpy:
1355 case Builtin::BI__builtin_stpncpy: {
1361 DiagID = diag::warn_fortify_source_size_mismatch;
1362 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1363 DestinationSize = ComputeSizeArgument(0);
1367 case Builtin::BImemcpy:
1368 case Builtin::BI__builtin_memcpy:
1369 case Builtin::BImemmove:
1370 case Builtin::BI__builtin_memmove:
1371 case Builtin::BImemset:
1372 case Builtin::BI__builtin_memset:
1373 case Builtin::BImempcpy:
1374 case Builtin::BI__builtin_mempcpy: {
1375 DiagID = diag::warn_fortify_source_overflow;
1376 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1377 DestinationSize = ComputeSizeArgument(0);
1380 case Builtin::BIsnprintf:
1381 case Builtin::BI__builtin_snprintf:
1382 case Builtin::BIvsnprintf:
1383 case Builtin::BI__builtin_vsnprintf: {
1384 DiagID = diag::warn_fortify_source_size_mismatch;
1385 SourceSize = ComputeExplicitObjectSizeArgument(1);
1387 StringRef FormatStrRef;
1391 EstimateSizeFormatHandler H(FormatStrRef);
1392 const char *FormatBytes = FormatStrRef.data();
1394 H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
1397 llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1398 .extOrTrunc(SizeTypeWidth);
1399 if (FormatSize > *SourceSize && *SourceSize != 0) {
1400 unsigned TruncationDiagID =
1401 H.isKernelCompatible() ? diag::warn_format_truncation
1402 : diag::warn_format_truncation_non_kprintf;
1405 SourceSize->toString(SpecifiedSizeStr, 10);
1406 FormatSize.toString(FormatSizeStr, 10);
1407 DiagRuntimeBehavior(TheCall->
getBeginLoc(), TheCall,
1408 PDiag(TruncationDiagID)
1409 << GetFunctionName() << SpecifiedSizeStr
1414 DestinationSize = ComputeSizeArgument(0);
1418 if (!SourceSize || !DestinationSize ||
1419 llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
1422 StringRef FunctionName = GetFunctionName();
1426 DestinationSize->toString(DestinationStr, 10);
1427 SourceSize->toString(SourceStr, 10);
1428 DiagRuntimeBehavior(TheCall->
getBeginLoc(), TheCall,
1430 << FunctionName << DestinationStr << SourceStr);
1443 while (S && !S->isSEHExceptScope())
1445 if (!S || !(S->getFlags() & NeededScopeFlags)) {
1448 << DRE->getDecl()->getIdentifier();
1466 unsigned ArgCounter = 0;
1467 bool IllegalParams =
false;
1471 I != E; ++I, ++ArgCounter) {
1472 if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
1473 (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
1479 if (isa<BlockExpr>(BlockArg)) {
1480 BlockDecl *BD = cast<BlockExpr>(BlockArg)->getBlockDecl();
1482 }
else if (isa<DeclRefExpr>(BlockArg)) {
1483 ErrorLoc = cast<DeclRefExpr>(BlockArg)->getBeginLoc();
1486 diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
1487 IllegalParams =
true;
1491 return IllegalParams;
1501 S.
Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
1502 << 1 << Call->getDirectCallee()
1503 <<
"cl_khr_subgroups or __opencl_c_subgroups";
1519 S.
Diag(NDRangeArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1526 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1542 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1554 unsigned Start,
unsigned End) {
1555 bool IllegalParams =
false;
1556 for (
unsigned I = Start; I <=
End; ++I)
1559 return IllegalParams;
1566 unsigned NumNonVarArgs) {
1569 unsigned NumBlockParams =
1571 unsigned TotalNumArgs = TheCall->
getNumArgs();
1575 if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
1577 diag::err_opencl_enqueue_kernel_local_size_args);
1617 diag::err_typecheck_call_too_few_args_at_least)
1618 << 0 << 4 << NumArgs << 0;
1630 diag::err_opencl_builtin_expected_type)
1638 diag::err_opencl_builtin_expected_type)
1639 << TheCall->
getDirectCallee() <<
"'kernel_enqueue_flags_t' (i.e. uint)";
1646 diag::err_opencl_builtin_expected_type)
1665 diag::err_opencl_enqueue_kernel_blocks_no_args);
1689 diag::err_opencl_builtin_expected_type)
1702 diag::err_opencl_builtin_expected_type)
1714 diag::err_opencl_builtin_expected_type)
1728 diag::err_opencl_enqueue_kernel_incorrect_args);
1734 return D->
getAttr<OpenCLAccessAttr>();
1739 const Expr *Arg0 = Call->getArg(0);
1742 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1746 OpenCLAccessAttr *AccessQual =
1752 switch (Call->getDirectCallee()->getBuiltinID()) {
1753 case Builtin::BIread_pipe:
1754 case Builtin::BIreserve_read_pipe:
1755 case Builtin::BIcommit_read_pipe:
1756 case Builtin::BIwork_group_reserve_read_pipe:
1757 case Builtin::BIsub_group_reserve_read_pipe:
1758 case Builtin::BIwork_group_commit_read_pipe:
1759 case Builtin::BIsub_group_commit_read_pipe:
1760 if (!(!AccessQual || AccessQual->isReadOnly())) {
1762 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1767 case Builtin::BIwrite_pipe:
1768 case Builtin::BIreserve_write_pipe:
1769 case Builtin::BIcommit_write_pipe:
1770 case Builtin::BIwork_group_reserve_write_pipe:
1771 case Builtin::BIsub_group_reserve_write_pipe:
1772 case Builtin::BIwork_group_commit_write_pipe:
1773 case Builtin::BIsub_group_commit_write_pipe:
1774 if (!(AccessQual && AccessQual->isWriteOnly())) {
1776 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1789 const Expr *Arg0 = Call->getArg(0);
1790 const Expr *ArgIdx = Call->getArg(Idx);
1799 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1814 switch (Call->getNumArgs()) {
1831 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1832 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1834 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1839 const Expr *Arg2 = Call->getArg(2);
1842 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1853 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
1854 << Call->getDirectCallee() << Call->getSourceRange();
1874 if (!Call->getArg(1)->getType()->isIntegerType() &&
1875 !Call->getArg(1)->getType()->isUnsignedIntegerType()) {
1876 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1878 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1903 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1904 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1906 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1922 if (!Call->getArg(0)->getType()->isPipeType()) {
1923 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1924 << Call->getDirectCallee() << Call->getArg(0)->getSourceRange();
1941 auto RT = Call->getArg(0)->getType();
1942 if (!RT->isPointerType() || RT->getPointeeType()
1944 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
1945 << Call->getArg(0) << Call->getDirectCallee() << Call->getSourceRange();
1950 S.
Diag(Call->getArg(0)->getBeginLoc(),
1951 diag::warn_opencl_generic_address_space_arg)
1952 << Call->getDirectCallee()->getNameInfo().getAsString()
1953 << Call->getArg(0)->getSourceRange();
1956 RT = RT->getPointeeType();
1957 auto Qual = RT.getQualifiers();
1958 switch (BuiltinID) {
1959 case Builtin::BIto_global:
1962 case Builtin::BIto_local:
1965 case Builtin::BIto_private:
1969 llvm_unreachable(
"Invalid builtin function");
1972 RT.getUnqualifiedType(), Qual)));
1978 enum PointerAuthOpKind {
2023 llvm::raw_svector_ostream Str(
Value);
2032 Result = KeyValue->getZExtValue();
2037 PointerAuthOpKind OpKind) {
2045 auto AllowsPointer = [](PointerAuthOpKind OpKind) {
2046 return OpKind != PAO_BlendInteger;
2048 auto AllowsInteger = [](PointerAuthOpKind OpKind) {
2049 return OpKind == PAO_Discriminator || OpKind == PAO_BlendInteger ||
2050 OpKind == PAO_SignGeneric;
2059 }
else if (AllowsInteger(OpKind) &&
2066 <<
unsigned(OpKind == PAO_Discriminator ? 1
2067 : OpKind == PAO_BlendPointer ? 2
2068 : OpKind == PAO_BlendInteger ? 3
2070 <<
unsigned(AllowsInteger(OpKind) ? (AllowsPointer(OpKind) ? 2 : 1) : 0)
2081 if ((OpKind == PAO_Sign || OpKind == PAO_Auth) &&
2084 ? diag::warn_ptrauth_sign_null_pointer
2085 : diag::warn_ptrauth_auth_null_pointer)
2101 Call->setType(Call->getArgs()[0]->getType());
2132 PointerAuthOpKind OpKind) {
2142 Call->setType(Call->getArgs()[0]->getType());
2158 Call->setType(Call->getArgs()[0]->getType());
2183 auto DiagSelect = [&]() -> std::optional<unsigned> {
2190 return std::optional<unsigned>{};
2205 diag::err_incomplete_type))
2209 "Unhandled non-object pointer case");
2227 llvm::Triple::ObjectFormatType CurObjFormat =
2229 if (llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {
2242 llvm::Triple::ArchType CurArch =
2244 if (llvm::is_contained(SupportedArchs, CurArch))
2254 bool Sema::CheckTSBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
2261 case llvm::Triple::arm:
2262 case llvm::Triple::armeb:
2263 case llvm::Triple::thumb:
2264 case llvm::Triple::thumbeb:
2265 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
2266 case llvm::Triple::aarch64:
2267 case llvm::Triple::aarch64_32:
2268 case llvm::Triple::aarch64_be:
2269 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
2270 case llvm::Triple::bpfeb:
2271 case llvm::Triple::bpfel:
2272 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
2273 case llvm::Triple::hexagon:
2274 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
2275 case llvm::Triple::mips:
2276 case llvm::Triple::mipsel:
2277 case llvm::Triple::mips64:
2278 case llvm::Triple::mips64el:
2279 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
2280 case llvm::Triple::systemz:
2281 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
2282 case llvm::Triple::x86:
2283 case llvm::Triple::x86_64:
2284 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
2285 case llvm::Triple::ppc:
2286 case llvm::Triple::ppcle:
2287 case llvm::Triple::ppc64:
2288 case llvm::Triple::ppc64le:
2289 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
2290 case llvm::Triple::amdgcn:
2291 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
2292 case llvm::Triple::riscv32:
2293 case llvm::Triple::riscv64:
2294 return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
2295 case llvm::Triple::loongarch32:
2296 case llvm::Triple::loongarch64:
2297 return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
2298 case llvm::Triple::wasm32:
2299 case llvm::Triple::wasm64:
2300 return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
2301 case llvm::Triple::nvptx:
2302 case llvm::Triple::nvptx64:
2303 return CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
2314 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2315 << ArgIndex << 0 << ArgTy;
2325 EltTy = VecTy->getElementType();
2328 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2329 << ArgIndex << 5 << ArgTy;
2339 const TargetInfo *AuxTI,
unsigned BuiltinID) {
2340 assert((BuiltinID == Builtin::BI__builtin_cpu_supports ||
2341 BuiltinID == Builtin::BI__builtin_cpu_is) &&
2342 "Expecting __builtin_cpu_...");
2344 bool IsCPUSupports = BuiltinID == Builtin::BI__builtin_cpu_supports;
2346 auto SupportsBI = [=](
const TargetInfo *TInfo) {
2347 return TInfo && ((IsCPUSupports && TInfo->supportsCpuSupports()) ||
2348 (!IsCPUSupports && TInfo->supportsCpuIs()));
2350 if (!SupportsBI(&TI) && SupportsBI(AuxTI))
2354 return S.
Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
2359 ? diag::err_builtin_aix_os_unsupported
2360 : diag::err_builtin_target_unsupported)
2365 if (!isa<StringLiteral>(Arg))
2366 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
2370 StringRef Feature = cast<StringLiteral>(Arg)->getString();
2417 TheCall->
setArg(0, Arg0);
2423 << 1 << 7 << Arg0Ty;
2433 TheCall->
setArg(1, Arg1);
2439 << 2 << 8 << Arg1Ty;
2448 Sema::CheckBuiltinFunctionCall(
FunctionDecl *FDecl,
unsigned BuiltinID,
2453 unsigned ICEArguments = 0;
2460 for (
unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2462 if ((ICEArguments & (1 << ArgNo)) == 0)
continue;
2467 if (ArgNo < TheCall->getNumArgs() &&
2468 BuiltinConstantArg(TheCall, ArgNo, Result))
2470 ICEArguments &= ~(1 << ArgNo);
2474 switch (BuiltinID) {
2475 case Builtin::BI__builtin_cpu_supports:
2476 case Builtin::BI__builtin_cpu_is:
2481 case Builtin::BI__builtin_cpu_init:
2488 case Builtin::BI__builtin___CFStringMakeConstantString:
2492 *
this, BuiltinID, TheCall,
2493 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2496 "Wrong # arguments to builtin CFStringMakeConstantString");
2497 if (CheckObjCString(TheCall->
getArg(0)))
2500 case Builtin::BI__builtin_ms_va_start:
2501 case Builtin::BI__builtin_stdarg_start:
2502 case Builtin::BI__builtin_va_start:
2503 if (BuiltinVAStart(BuiltinID, TheCall))
2506 case Builtin::BI__va_start: {
2508 case llvm::Triple::aarch64:
2509 case llvm::Triple::arm:
2510 case llvm::Triple::thumb:
2511 if (BuiltinVAStartARMMicrosoft(TheCall))
2515 if (BuiltinVAStart(BuiltinID, TheCall))
2523 case Builtin::BI_interlockedbittestandset_acq:
2524 case Builtin::BI_interlockedbittestandset_rel:
2525 case Builtin::BI_interlockedbittestandset_nf:
2526 case Builtin::BI_interlockedbittestandreset_acq:
2527 case Builtin::BI_interlockedbittestandreset_rel:
2528 case Builtin::BI_interlockedbittestandreset_nf:
2530 *
this, BuiltinID, TheCall,
2531 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2536 case Builtin::BI_bittest64:
2537 case Builtin::BI_bittestandcomplement64:
2538 case Builtin::BI_bittestandreset64:
2539 case Builtin::BI_bittestandset64:
2540 case Builtin::BI_interlockedbittestandreset64:
2541 case Builtin::BI_interlockedbittestandset64:
2543 {llvm::Triple::x86_64, llvm::Triple::arm,
2544 llvm::Triple::thumb,
2545 llvm::Triple::aarch64}))
2549 case Builtin::BI__builtin_set_flt_rounds:
2551 {llvm::Triple::x86, llvm::Triple::x86_64,
2552 llvm::Triple::arm, llvm::Triple::thumb,
2553 llvm::Triple::aarch64}))
2557 case Builtin::BI__builtin_isgreater:
2558 case Builtin::BI__builtin_isgreaterequal:
2559 case Builtin::BI__builtin_isless:
2560 case Builtin::BI__builtin_islessequal:
2561 case Builtin::BI__builtin_islessgreater:
2562 case Builtin::BI__builtin_isunordered:
2563 if (BuiltinUnorderedCompare(TheCall, BuiltinID))
2566 case Builtin::BI__builtin_fpclassify:
2567 if (BuiltinFPClassification(TheCall, 6, BuiltinID))
2570 case Builtin::BI__builtin_isfpclass:
2571 if (BuiltinFPClassification(TheCall, 2, BuiltinID))
2574 case Builtin::BI__builtin_isfinite:
2575 case Builtin::BI__builtin_isinf:
2576 case Builtin::BI__builtin_isinf_sign:
2577 case Builtin::BI__builtin_isnan:
2578 case Builtin::BI__builtin_issignaling:
2579 case Builtin::BI__builtin_isnormal:
2580 case Builtin::BI__builtin_issubnormal:
2581 case Builtin::BI__builtin_iszero:
2582 case Builtin::BI__builtin_signbit:
2583 case Builtin::BI__builtin_signbitf:
2584 case Builtin::BI__builtin_signbitl:
2585 if (BuiltinFPClassification(TheCall, 1, BuiltinID))
2588 case Builtin::BI__builtin_shufflevector:
2589 return BuiltinShuffleVector(TheCall);
2592 case Builtin::BI__builtin_prefetch:
2593 if (BuiltinPrefetch(TheCall))
2596 case Builtin::BI__builtin_alloca_with_align:
2597 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2598 if (BuiltinAllocaWithAlign(TheCall))
2601 case Builtin::BI__builtin_alloca:
2602 case Builtin::BI__builtin_alloca_uninitialized:
2606 case Builtin::BI__arithmetic_fence:
2607 if (BuiltinArithmeticFence(TheCall))
2610 case Builtin::BI__assume:
2611 case Builtin::BI__builtin_assume:
2612 if (BuiltinAssume(TheCall))
2615 case Builtin::BI__builtin_assume_aligned:
2616 if (BuiltinAssumeAligned(TheCall))
2619 case Builtin::BI__builtin_dynamic_object_size:
2620 case Builtin::BI__builtin_object_size:
2621 if (BuiltinConstantArgRange(TheCall, 1, 0, 3))
2624 case Builtin::BI__builtin_longjmp:
2625 if (BuiltinLongjmp(TheCall))
2628 case Builtin::BI__builtin_setjmp:
2629 if (BuiltinSetjmp(TheCall))
2632 case Builtin::BI__builtin_classify_type:
2636 case Builtin::BI__builtin_complex:
2637 if (BuiltinComplex(TheCall))
2640 case Builtin::BI__builtin_constant_p: {
2648 case Builtin::BI__builtin_launder:
2650 case Builtin::BI__sync_fetch_and_add:
2651 case Builtin::BI__sync_fetch_and_add_1:
2652 case Builtin::BI__sync_fetch_and_add_2:
2653 case Builtin::BI__sync_fetch_and_add_4:
2654 case Builtin::BI__sync_fetch_and_add_8:
2655 case Builtin::BI__sync_fetch_and_add_16:
2656 case Builtin::BI__sync_fetch_and_sub:
2657 case Builtin::BI__sync_fetch_and_sub_1:
2658 case Builtin::BI__sync_fetch_and_sub_2:
2659 case Builtin::BI__sync_fetch_and_sub_4:
2660 case Builtin::BI__sync_fetch_and_sub_8:
2661 case Builtin::BI__sync_fetch_and_sub_16:
2662 case Builtin::BI__sync_fetch_and_or:
2663 case Builtin::BI__sync_fetch_and_or_1:
2664 case Builtin::BI__sync_fetch_and_or_2:
2665 case Builtin::BI__sync_fetch_and_or_4:
2666 case Builtin::BI__sync_fetch_and_or_8:
2667 case Builtin::BI__sync_fetch_and_or_16:
2668 case Builtin::BI__sync_fetch_and_and:
2669 case Builtin::BI__sync_fetch_and_and_1:
2670 case Builtin::BI__sync_fetch_and_and_2:
2671 case Builtin::BI__sync_fetch_and_and_4:
2672 case Builtin::BI__sync_fetch_and_and_8:
2673 case Builtin::BI__sync_fetch_and_and_16:
2674 case Builtin::BI__sync_fetch_and_xor:
2675 case Builtin::BI__sync_fetch_and_xor_1:
2676 case Builtin::BI__sync_fetch_and_xor_2:
2677 case Builtin::BI__sync_fetch_and_xor_4:
2678 case Builtin::BI__sync_fetch_and_xor_8:
2679 case Builtin::BI__sync_fetch_and_xor_16:
2680 case Builtin::BI__sync_fetch_and_nand:
2681 case Builtin::BI__sync_fetch_and_nand_1:
2682 case Builtin::BI__sync_fetch_and_nand_2:
2683 case Builtin::BI__sync_fetch_and_nand_4:
2684 case Builtin::BI__sync_fetch_and_nand_8:
2685 case Builtin::BI__sync_fetch_and_nand_16:
2686 case Builtin::BI__sync_add_and_fetch:
2687 case Builtin::BI__sync_add_and_fetch_1:
2688 case Builtin::BI__sync_add_and_fetch_2:
2689 case Builtin::BI__sync_add_and_fetch_4:
2690 case Builtin::BI__sync_add_and_fetch_8:
2691 case Builtin::BI__sync_add_and_fetch_16:
2692 case Builtin::BI__sync_sub_and_fetch:
2693 case Builtin::BI__sync_sub_and_fetch_1:
2694 case Builtin::BI__sync_sub_and_fetch_2:
2695 case Builtin::BI__sync_sub_and_fetch_4:
2696 case Builtin::BI__sync_sub_and_fetch_8:
2697 case Builtin::BI__sync_sub_and_fetch_16:
2698 case Builtin::BI__sync_and_and_fetch:
2699 case Builtin::BI__sync_and_and_fetch_1:
2700 case Builtin::BI__sync_and_and_fetch_2:
2701 case Builtin::BI__sync_and_and_fetch_4:
2702 case Builtin::BI__sync_and_and_fetch_8:
2703 case Builtin::BI__sync_and_and_fetch_16:
2704 case Builtin::BI__sync_or_and_fetch:
2705 case Builtin::BI__sync_or_and_fetch_1:
2706 case Builtin::BI__sync_or_and_fetch_2:
2707 case Builtin::BI__sync_or_and_fetch_4:
2708 case Builtin::BI__sync_or_and_fetch_8:
2709 case Builtin::BI__sync_or_and_fetch_16:
2710 case Builtin::BI__sync_xor_and_fetch:
2711 case Builtin::BI__sync_xor_and_fetch_1:
2712 case Builtin::BI__sync_xor_and_fetch_2:
2713 case Builtin::BI__sync_xor_and_fetch_4:
2714 case Builtin::BI__sync_xor_and_fetch_8:
2715 case Builtin::BI__sync_xor_and_fetch_16:
2716 case Builtin::BI__sync_nand_and_fetch:
2717 case Builtin::BI__sync_nand_and_fetch_1:
2718 case Builtin::BI__sync_nand_and_fetch_2:
2719 case Builtin::BI__sync_nand_and_fetch_4:
2720 case Builtin::BI__sync_nand_and_fetch_8:
2721 case Builtin::BI__sync_nand_and_fetch_16:
2722 case Builtin::BI__sync_val_compare_and_swap:
2723 case Builtin::BI__sync_val_compare_and_swap_1:
2724 case Builtin::BI__sync_val_compare_and_swap_2:
2725 case Builtin::BI__sync_val_compare_and_swap_4:
2726 case Builtin::BI__sync_val_compare_and_swap_8:
2727 case Builtin::BI__sync_val_compare_and_swap_16:
2728 case Builtin::BI__sync_bool_compare_and_swap:
2729 case Builtin::BI__sync_bool_compare_and_swap_1:
2730 case Builtin::BI__sync_bool_compare_and_swap_2:
2731 case Builtin::BI__sync_bool_compare_and_swap_4:
2732 case Builtin::BI__sync_bool_compare_and_swap_8:
2733 case Builtin::BI__sync_bool_compare_and_swap_16:
2734 case Builtin::BI__sync_lock_test_and_set:
2735 case Builtin::BI__sync_lock_test_and_set_1:
2736 case Builtin::BI__sync_lock_test_and_set_2:
2737 case Builtin::BI__sync_lock_test_and_set_4:
2738 case Builtin::BI__sync_lock_test_and_set_8:
2739 case Builtin::BI__sync_lock_test_and_set_16:
2740 case Builtin::BI__sync_lock_release:
2741 case Builtin::BI__sync_lock_release_1:
2742 case Builtin::BI__sync_lock_release_2:
2743 case Builtin::BI__sync_lock_release_4:
2744 case Builtin::BI__sync_lock_release_8:
2745 case Builtin::BI__sync_lock_release_16:
2746 case Builtin::BI__sync_swap:
2747 case Builtin::BI__sync_swap_1:
2748 case Builtin::BI__sync_swap_2:
2749 case Builtin::BI__sync_swap_4:
2750 case Builtin::BI__sync_swap_8:
2751 case Builtin::BI__sync_swap_16:
2752 return BuiltinAtomicOverloaded(TheCallResult);
2753 case Builtin::BI__sync_synchronize:
2757 case Builtin::BI__builtin_nontemporal_load:
2758 case Builtin::BI__builtin_nontemporal_store:
2759 return BuiltinNontemporalOverloaded(TheCallResult);
2760 case Builtin::BI__builtin_memcpy_inline: {
2773 case Builtin::BI__builtin_memset_inline: {
2784 #define BUILTIN(ID, TYPE, ATTRS)
2785 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2786 case Builtin::BI##ID: \
2787 return AtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2788 #include "clang/Basic/Builtins.inc"
2789 case Builtin::BI__annotation:
2793 case Builtin::BI__builtin_annotation:
2797 case Builtin::BI__builtin_addressof:
2801 case Builtin::BI__builtin_function_start:
2805 case Builtin::BI__builtin_is_aligned:
2806 case Builtin::BI__builtin_align_up:
2807 case Builtin::BI__builtin_align_down:
2811 case Builtin::BI__builtin_add_overflow:
2812 case Builtin::BI__builtin_sub_overflow:
2813 case Builtin::BI__builtin_mul_overflow:
2817 case Builtin::BI__builtin_operator_new:
2818 case Builtin::BI__builtin_operator_delete: {
2819 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2821 BuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2823 CorrectDelayedTyposInExpr(TheCallResult.get());
2826 case Builtin::BI__builtin_dump_struct:
2828 case Builtin::BI__builtin_expect_with_probability: {
2839 Diag(ProbArg->
getBeginLoc(), diag::err_probability_not_constant_float)
2842 Diag(PDiag.first, PDiag.second);
2846 bool LoseInfo =
false;
2847 Probability.convert(llvm::APFloat::IEEEdouble(),
2848 llvm::RoundingMode::Dynamic, &LoseInfo);
2857 case Builtin::BI__builtin_preserve_access_index:
2861 case Builtin::BI__builtin_call_with_static_chain:
2865 case Builtin::BI__exception_code:
2866 case Builtin::BI_exception_code:
2868 diag::err_seh___except_block))
2871 case Builtin::BI__exception_info:
2872 case Builtin::BI_exception_info:
2874 diag::err_seh___except_filter))
2877 case Builtin::BI__GetExceptionInfo:
2881 if (CheckCXXThrowOperand(
2889 case Builtin::BIaddressof:
2890 case Builtin::BI__addressof:
2891 case Builtin::BIforward:
2892 case Builtin::BIforward_like:
2893 case Builtin::BImove:
2894 case Builtin::BImove_if_noexcept:
2895 case Builtin::BIas_const: {
2903 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2904 BuiltinID == Builtin::BI__addressof;
2906 (ReturnsPointer ? Result->isAnyPointerType()
2907 : Result->isReferenceType()) &&
2909 Result->getPointeeType()))) {
2910 Diag(TheCall->
getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2916 case Builtin::BI__builtin_ptrauth_strip:
2918 case Builtin::BI__builtin_ptrauth_blend_discriminator:
2920 case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
2922 case Builtin::BI__builtin_ptrauth_auth:
2924 case Builtin::BI__builtin_ptrauth_sign_generic_data:
2926 case Builtin::BI__builtin_ptrauth_auth_and_resign:
2929 case Builtin::BIread_pipe:
2930 case Builtin::BIwrite_pipe:
2936 case Builtin::BIreserve_read_pipe:
2937 case Builtin::BIreserve_write_pipe:
2938 case Builtin::BIwork_group_reserve_read_pipe:
2939 case Builtin::BIwork_group_reserve_write_pipe:
2943 case Builtin::BIsub_group_reserve_read_pipe:
2944 case Builtin::BIsub_group_reserve_write_pipe:
2949 case Builtin::BIcommit_read_pipe:
2950 case Builtin::BIcommit_write_pipe:
2951 case Builtin::BIwork_group_commit_read_pipe:
2952 case Builtin::BIwork_group_commit_write_pipe:
2956 case Builtin::BIsub_group_commit_read_pipe:
2957 case Builtin::BIsub_group_commit_write_pipe:
2962 case Builtin::BIget_pipe_num_packets:
2963 case Builtin::BIget_pipe_max_packets:
2967 case Builtin::BIto_global:
2968 case Builtin::BIto_local:
2969 case Builtin::BIto_private:
2974 case Builtin::BIenqueue_kernel:
2978 case Builtin::BIget_kernel_work_group_size:
2979 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2983 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2984 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2988 case Builtin::BI__builtin_os_log_format:
2989 Cleanup.setExprNeedsCleanups(
true);
2991 case Builtin::BI__builtin_os_log_format_buffer_size:
2992 if (BuiltinOSLogFormat(TheCall))
2995 case Builtin::BI__builtin_intel_fpga_reg:
2998 <<
"__builtin_intel_fpga_reg"
3002 if (CheckIntelFPGARegBuiltinFunctionCall(BuiltinID, TheCall))
3005 case Builtin::BI__builtin_intel_sycl_ptr_annotation:
3008 <<
"__builtin_intel_sycl_ptr_annotation"
3012 if (CheckIntelSYCLPtrAnnotationBuiltinFunctionCall(BuiltinID, TheCall))
3015 case Builtin::BI__builtin_intel_sycl_alloca:
3016 case Builtin::BI__builtin_intel_sycl_alloca_with_align:
3019 << (BuiltinID == Builtin::BI__builtin_intel_sycl_alloca
3020 ?
"__builtin_intel_sycl_alloca"
3021 :
"__builtin_intel_sycl_alloca_with_align")
3025 if (getASTContext().getTargetInfo().getTriple().isSPIRAOT()) {
3028 << (BuiltinID == Builtin::BI__builtin_intel_sycl_alloca_with_align);
3031 if (CheckIntelSYCLAllocaBuiltinFunctionCall(BuiltinID, TheCall))
3034 case Builtin::BI__builtin_intel_fpga_mem:
3037 <<
"__builtin_intel_fpga_mem"
3041 if (CheckIntelFPGAMemBuiltinFunctionCall(TheCall))
3044 case Builtin::BI__builtin_frame_address:
3045 case Builtin::BI__builtin_return_address: {
3046 if (BuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
3054 Result.Val.getInt() != 0)
3056 << ((BuiltinID == Builtin::BI__builtin_return_address)
3057 ?
"__builtin_return_address"
3058 :
"__builtin_frame_address")
3063 case Builtin::BI__builtin_nondeterministic_value: {
3064 if (BuiltinNonDeterministicValue(TheCall))
3071 case Builtin::BI__builtin_elementwise_abs: {
3072 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3079 EltTy = VecTy->getElementType();
3082 diag::err_builtin_invalid_arg_type)
3091 case Builtin::BI__builtin_elementwise_ceil:
3092 case Builtin::BI__builtin_elementwise_cos:
3093 case Builtin::BI__builtin_elementwise_exp:
3094 case Builtin::BI__builtin_elementwise_exp2:
3095 case Builtin::BI__builtin_elementwise_floor:
3096 case Builtin::BI__builtin_elementwise_log:
3097 case Builtin::BI__builtin_elementwise_log2:
3098 case Builtin::BI__builtin_elementwise_log10:
3099 case Builtin::BI__builtin_elementwise_roundeven:
3100 case Builtin::BI__builtin_elementwise_round:
3101 case Builtin::BI__builtin_elementwise_rint:
3102 case Builtin::BI__builtin_elementwise_nearbyint:
3103 case Builtin::BI__builtin_elementwise_sin:
3104 case Builtin::BI__builtin_elementwise_sqrt:
3105 case Builtin::BI__builtin_elementwise_trunc:
3106 case Builtin::BI__builtin_elementwise_canonicalize: {
3107 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3116 case Builtin::BI__builtin_elementwise_fma: {
3117 if (BuiltinElementwiseTernaryMath(TheCall))
3124 case Builtin::BI__builtin_elementwise_pow: {
3125 if (BuiltinElementwiseMath(TheCall))
3139 case Builtin::BI__builtin_elementwise_add_sat:
3140 case Builtin::BI__builtin_elementwise_sub_sat: {
3141 if (BuiltinElementwiseMath(TheCall))
3149 EltTy = VecTy->getElementType();
3159 case Builtin::BI__builtin_elementwise_min:
3160 case Builtin::BI__builtin_elementwise_max:
3161 if (BuiltinElementwiseMath(TheCall))
3165 case Builtin::BI__builtin_elementwise_bitreverse: {
3166 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
3174 EltTy = VecTy->getElementType();
3184 case Builtin::BI__builtin_elementwise_copysign: {
3204 diag::err_typecheck_call_different_arg_types)
3205 << MagnitudeTy << SignTy;
3213 case Builtin::BI__builtin_reduce_max:
3214 case Builtin::BI__builtin_reduce_min: {
3215 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3226 TheCall->
setType(TyA->getElementType());
3232 case Builtin::BI__builtin_reduce_add:
3233 case Builtin::BI__builtin_reduce_mul:
3234 case Builtin::BI__builtin_reduce_xor:
3235 case Builtin::BI__builtin_reduce_or:
3236 case Builtin::BI__builtin_reduce_and: {
3237 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
3242 if (!TyA || !TyA->getElementType()->isIntegerType()) {
3247 TheCall->
setType(TyA->getElementType());
3251 case Builtin::BI__builtin_matrix_transpose:
3252 return BuiltinMatrixTranspose(TheCall, TheCallResult);
3254 case Builtin::BI__builtin_matrix_column_major_load:
3255 return BuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
3257 case Builtin::BI__builtin_matrix_column_major_store:
3258 return BuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
3260 case Builtin::BI__builtin_get_device_side_mangled_name: {
3261 auto Check = [](
CallExpr *TheCall) {
3267 auto *D = DRE->getDecl();
3268 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
3270 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
3271 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
3273 if (!Check(TheCall)) {
3275 diag::err_hip_invalid_args_builtin_mangled_name);
3280 case Builtin::BI__builtin_popcountg:
3284 case Builtin::BI__builtin_clzg:
3285 case Builtin::BI__builtin_ctzg:
3290 case Builtin::BI__builtin_allow_runtime_check: {
3302 if (getLangOpts().
HLSL && CheckHLSLBuiltinFunctionCall(BuiltinID, TheCall))
3310 "Aux Target Builtin, but not an aux target?");
3312 if (CheckTSBuiltinFunctionCall(
3318 if (getLangOpts().SYCLIsDevice)
3320 diag::err_builtin_target_unsupported);
3322 if (CheckTSBuiltinFunctionCall(Context.
getTargetInfo(), BuiltinID,
3328 return TheCallResult;
3332 static unsigned RFT(
unsigned t,
bool shift =
false,
bool ForceQuad =
false) {
3334 int IsQuad = ForceQuad ?
true :
Type.isQuad();
3335 switch (
Type.getEltType()) {
3338 return shift ? 7 : (8 << IsQuad) - 1;
3341 return shift ? 15 : (4 << IsQuad) - 1;
3343 return shift ? 31 : (2 << IsQuad) - 1;
3346 return shift ? 63 : (1 << IsQuad) - 1;
3348 return shift ? 127 : (1 << IsQuad) - 1;
3350 assert(!shift &&
"cannot shift float types!");
3351 return (4 << IsQuad) - 1;
3353 assert(!shift &&
"cannot shift float types!");
3354 return (2 << IsQuad) - 1;
3356 assert(!shift &&
"cannot shift float types!");
3357 return (1 << IsQuad) - 1;
3359 assert(!shift &&
"cannot shift float types!");
3360 return (4 << IsQuad) - 1;
3362 llvm_unreachable(
"Invalid NeonTypeFlag!");
3369 bool IsPolyUnsigned,
bool IsInt64Long) {
3403 llvm_unreachable(
"Invalid NeonTypeFlag!");
3427 bool Sema::ParseSVEImmChecks(
3430 bool HasError =
false;
3431 for (
auto &I : ImmChecks) {
3432 int ArgNum, CheckTy, ElementSizeInBits;
3433 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
3439 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
3440 int ErrDiag) ->
bool {
3448 if (BuiltinConstantArg(TheCall, ArgNum, Imm))
3451 if (!CheckImm(Imm.getSExtValue()))
3457 case SVETypeFlags::ImmCheck0_31:
3458 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
3461 case SVETypeFlags::ImmCheck0_13:
3462 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
3465 case SVETypeFlags::ImmCheck1_16:
3466 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
3469 case SVETypeFlags::ImmCheck0_7:
3470 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
3473 case SVETypeFlags::ImmCheck1_1:
3474 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 1))
3477 case SVETypeFlags::ImmCheck1_3:
3478 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 3))
3481 case SVETypeFlags::ImmCheck1_7:
3482 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, 7))
3485 case SVETypeFlags::ImmCheckExtract:
3486 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3487 (2048 / ElementSizeInBits) - 1))
3490 case SVETypeFlags::ImmCheckShiftRight:
3491 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
3494 case SVETypeFlags::ImmCheckShiftRightNarrow:
3495 if (BuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits / 2))
3498 case SVETypeFlags::ImmCheckShiftLeft:
3499 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, ElementSizeInBits - 1))
3502 case SVETypeFlags::ImmCheckLaneIndex:
3503 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3504 (128 / (1 * ElementSizeInBits)) - 1))
3507 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
3508 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3509 (128 / (2 * ElementSizeInBits)) - 1))
3512 case SVETypeFlags::ImmCheckLaneIndexDot:
3513 if (BuiltinConstantArgRange(TheCall, ArgNum, 0,
3514 (128 / (4 * ElementSizeInBits)) - 1))
3517 case SVETypeFlags::ImmCheckComplexRot90_270:
3518 if (CheckImmediateInSet([](
int64_t V) {
return V == 90 ||
V == 270; },
3519 diag::err_rotation_argument_to_cadd))
3522 case SVETypeFlags::ImmCheckComplexRotAll90:
3523 if (CheckImmediateInSet(
3525 return V == 0 ||
V == 90 ||
V == 180 ||
V == 270;
3527 diag::err_rotation_argument_to_cmla))
3530 case SVETypeFlags::ImmCheck0_1:
3531 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3534 case SVETypeFlags::ImmCheck0_2:
3535 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3538 case SVETypeFlags::ImmCheck0_3:
3539 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3542 case SVETypeFlags::ImmCheck0_0:
3543 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3546 case SVETypeFlags::ImmCheck0_15:
3547 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3550 case SVETypeFlags::ImmCheck0_255:
3551 if (BuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3554 case SVETypeFlags::ImmCheck2_4_Mul2:
3555 if (BuiltinConstantArgRange(TheCall, ArgNum, 2, 4) ||
3556 BuiltinConstantArgMultiple(TheCall, ArgNum, 2))
3566 if (FD->
hasAttr<ArmLocallyStreamingAttr>())
3570 if (FPT->getAArch64SMEAttributes() &
3573 if (FPT->getAArch64SMEAttributes() &
3587 llvm::StringMap<bool> CallerFeatureMap;
3596 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3602 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3608 S.
Diag(TheCall->
getBeginLoc(), diag::warn_attribute_arm_sm_incompat_builtin)
3617 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZA());
3624 (FD->
hasAttr<ArmNewAttr>() && FD->
getAttr<ArmNewAttr>()->isNewZT0());
3628 switch (BuiltinID) {
3631 #define GET_SME_BUILTIN_GET_STATE
3632 #include "clang/Basic/arm_sme_builtins_za_state.inc"
3633 #undef GET_SME_BUILTIN_GET_STATE
3637 bool Sema::CheckSMEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3641 switch (BuiltinID) {
3642 #define GET_SME_STREAMING_ATTRS
3643 #include "clang/Basic/arm_sme_streaming_attrs.inc"
3644 #undef GET_SME_STREAMING_ATTRS
3652 diag::warn_attribute_arm_za_builtin_no_za_state)
3657 diag::warn_attribute_arm_zt0_builtin_no_zt0_state)
3664 switch (BuiltinID) {
3667 #define GET_SME_IMMEDIATE_CHECK
3668 #include "clang/Basic/arm_sme_sema_rangechecks.inc"
3669 #undef GET_SME_IMMEDIATE_CHECK
3672 return ParseSVEImmChecks(TheCall, ImmChecks);
3675 bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3679 switch (BuiltinID) {
3680 #define GET_SVE_STREAMING_ATTRS
3681 #include "clang/Basic/arm_sve_streaming_attrs.inc"
3682 #undef GET_SVE_STREAMING_ATTRS
3690 switch (BuiltinID) {
3693 #define GET_SVE_IMMEDIATE_CHECK
3694 #include "clang/Basic/arm_sve_sema_rangechecks.inc"
3695 #undef GET_SVE_IMMEDIATE_CHECK
3698 return ParseSVEImmChecks(TheCall, ImmChecks);
3701 bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3702 unsigned BuiltinID,
CallExpr *TheCall) {
3705 switch (BuiltinID) {
3708 #define GET_NEON_BUILTINS
3709 #define TARGET_BUILTIN(id, ...) case NEON::BI##id:
3710 #define BUILTIN(id, ...) case NEON::BI##id:
3711 #include "clang/Basic/arm_neon.inc"
3714 #undef TARGET_BUILTIN
3716 #undef GET_NEON_BUILTINS
3724 bool HasConstPtr =
false;
3725 switch (BuiltinID) {
3726 #define GET_NEON_OVERLOAD_CHECK
3727 #include "clang/Basic/arm_neon.inc"
3728 #include "clang/Basic/arm_fp16.inc"
3729 #undef GET_NEON_OVERLOAD_CHECK
3736 if (BuiltinConstantArg(TheCall, ImmArg, Result))
3739 TV = Result.getLimitedValue(64);
3740 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3745 if (PtrArgNum >= 0) {
3749 Arg = ICE->getSubExpr();
3750 ExprResult RHS = DefaultFunctionArrayLvalueConversion(Arg);
3753 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3754 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3755 Arch == llvm::Triple::aarch64_32 ||
3756 Arch == llvm::Triple::aarch64_be;
3763 AssignConvertType ConvTy;
3764 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
3767 if (DiagnoseAssignmentResult(ConvTy, Arg->
getBeginLoc(), LHSTy, RHSTy,
3768 RHS.
get(), AA_Assigning))
3774 unsigned i = 0, l = 0, u = 0;
3775 switch (BuiltinID) {
3778 #define GET_NEON_IMMEDIATE_CHECK
3779 #include "clang/Basic/arm_neon.inc"
3780 #include "clang/Basic/arm_fp16.inc"
3781 #undef GET_NEON_IMMEDIATE_CHECK
3784 return BuiltinConstantArgRange(TheCall, i, l, u + l);
3787 bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3788 switch (BuiltinID) {
3791 #include "clang/Basic/arm_mve_builtin_sema.inc"
3795 bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3798 switch (BuiltinID) {
3801 #include "clang/Basic/arm_cde_builtin_sema.inc"
3807 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3810 bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3811 const Expr *CoprocArg,
bool WantCDE) {
3812 if (isConstantEvaluatedContext())
3820 int64_t CoprocNo = CoprocNoAP.getExtValue();
3821 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3824 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3826 if (IsCDECoproc != WantCDE)
3833 bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3834 unsigned MaxWidth) {
3835 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3836 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3837 BuiltinID == ARM::BI__builtin_arm_strex ||
3838 BuiltinID == ARM::BI__builtin_arm_stlex ||
3839 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3840 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3841 BuiltinID == AArch64::BI__builtin_arm_strex ||
3842 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3843 "unexpected ARM builtin");
3844 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3845 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3846 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3847 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3859 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3860 ExprResult PointerArgRes = DefaultFunctionArrayLvalueConversion(PointerArg);
3863 PointerArg = PointerArgRes.
get();
3883 CastNeeded = CK_BitCast;
3884 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3891 PointerArgRes = ImpCastExprToType(PointerArg, AddrType, CastNeeded);
3894 PointerArg = PointerArgRes.
get();
3896 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3901 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3908 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3909 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3936 Context, ValType,
false);
3937 ValArg = PerformCopyInitialization(Entity,
SourceLocation(), ValArg);
3948 bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3950 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3951 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3952 BuiltinID == ARM::BI__builtin_arm_strex ||
3953 BuiltinID == ARM::BI__builtin_arm_stlex) {
3954 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3957 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3958 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3959 BuiltinConstantArgRange(TheCall, 2, 0, 1);
3962 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3963 BuiltinID == ARM::BI__builtin_arm_wsr64)
3964 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3966 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3967 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3968 BuiltinID == ARM::BI__builtin_arm_wsr ||
3969 BuiltinID == ARM::BI__builtin_arm_wsrp)
3970 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3972 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3974 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3976 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3982 switch (BuiltinID) {
3983 default:
return false;
3984 case ARM::BI__builtin_arm_ssat:
3985 return BuiltinConstantArgRange(TheCall, 1, 1, 32);
3986 case ARM::BI__builtin_arm_usat:
3987 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
3988 case ARM::BI__builtin_arm_ssat16:
3989 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
3990 case ARM::BI__builtin_arm_usat16:
3991 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
3992 case ARM::BI__builtin_arm_vcvtr_f:
3993 case ARM::BI__builtin_arm_vcvtr_d:
3994 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
3995 case ARM::BI__builtin_arm_dmb:
3996 case ARM::BI__builtin_arm_dsb:
3997 case ARM::BI__builtin_arm_isb:
3998 case ARM::BI__builtin_arm_dbg:
3999 return BuiltinConstantArgRange(TheCall, 0, 0, 15);
4000 case ARM::BI__builtin_arm_cdp:
4001 case ARM::BI__builtin_arm_cdp2:
4002 case ARM::BI__builtin_arm_mcr:
4003 case ARM::BI__builtin_arm_mcr2:
4004 case ARM::BI__builtin_arm_mrc:
4005 case ARM::BI__builtin_arm_mrc2:
4006 case ARM::BI__builtin_arm_mcrr:
4007 case ARM::BI__builtin_arm_mcrr2:
4008 case ARM::BI__builtin_arm_mrrc:
4009 case ARM::BI__builtin_arm_mrrc2:
4010 case ARM::BI__builtin_arm_ldc:
4011 case ARM::BI__builtin_arm_ldcl:
4012 case ARM::BI__builtin_arm_ldc2:
4013 case ARM::BI__builtin_arm_ldc2l:
4014 case ARM::BI__builtin_arm_stc:
4015 case ARM::BI__builtin_arm_stcl:
4016 case ARM::BI__builtin_arm_stc2:
4017 case ARM::BI__builtin_arm_stc2l:
4018 return BuiltinConstantArgRange(TheCall, 0, 0, 15) ||
4019 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
4024 bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
4027 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
4028 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
4029 BuiltinID == AArch64::BI__builtin_arm_strex ||
4030 BuiltinID == AArch64::BI__builtin_arm_stlex) {
4031 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
4034 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
4035 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
4036 BuiltinConstantArgRange(TheCall, 2, 0, 3) ||
4037 BuiltinConstantArgRange(TheCall, 3, 0, 1) ||
4038 BuiltinConstantArgRange(TheCall, 4, 0, 1);
4041 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
4042 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
4043 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
4044 BuiltinID == AArch64::BI__builtin_arm_wsr128)
4045 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4048 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
4049 BuiltinID == AArch64::BI__builtin_arm_addg ||
4050 BuiltinID == AArch64::BI__builtin_arm_gmi ||
4051 BuiltinID == AArch64::BI__builtin_arm_ldg ||
4052 BuiltinID == AArch64::BI__builtin_arm_stg ||
4053 BuiltinID == AArch64::BI__builtin_arm_subp) {
4054 return BuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
4057 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
4058 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
4059 BuiltinID == AArch64::BI__builtin_arm_wsr ||
4060 BuiltinID == AArch64::BI__builtin_arm_wsrp)
4061 return BuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
4066 if (BuiltinID == AArch64::BI_ReadStatusReg ||
4067 BuiltinID == AArch64::BI_WriteStatusReg)
4068 return BuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
4070 if (BuiltinID == AArch64::BI__getReg)
4071 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
4073 if (BuiltinID == AArch64::BI__break)
4074 return BuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
4076 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
4079 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
4082 if (CheckSMEBuiltinFunctionCall(BuiltinID, TheCall))
4087 unsigned i = 0, l = 0, u = 0;
4088 switch (BuiltinID) {
4089 default:
return false;
4090 case AArch64::BI__builtin_arm_dmb:
4091 case AArch64::BI__builtin_arm_dsb:
4092 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
4093 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
4096 return BuiltinConstantArgRange(TheCall, i, l, u + l);
4133 if (!RT->getDecl()->getDeclName().isEmpty())
4136 if (!ET->getDecl()->getDeclName().isEmpty())
4152 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
4156 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
4159 if (CE->getCastKind() != CK_IntegralToPointer &&
4160 CE->getCastKind() != CK_NullToPointer)
4164 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
4169 dyn_cast<EnumConstantDecl>(DR->getDecl());
4180 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
4183 bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
4185 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
4186 BuiltinID == BPF::BI__builtin_btf_type_id ||
4187 BuiltinID == BPF::BI__builtin_preserve_type_info ||
4188 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
4189 "unexpected BPF builtin");
4199 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
4200 kind = diag::err_preserve_field_info_not_const;
4201 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
4202 kind = diag::err_btf_type_id_not_const;
4203 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
4204 kind = diag::err_preserve_type_info_not_const;
4206 kind = diag::err_preserve_enum_value_not_const;
4212 Arg = TheCall->
getArg(0);
4213 bool InvalidArg =
false;
4214 bool ReturnUnsignedInt =
true;
4215 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
4218 kind = diag::err_preserve_field_info_not_field;
4220 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
4223 kind = diag::err_preserve_type_info_invalid;
4225 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
4228 kind = diag::err_preserve_enum_value_invalid;
4230 ReturnUnsignedInt =
false;
4231 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
4232 ReturnUnsignedInt =
false;
4240 if (ReturnUnsignedInt)
4247 bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
4260 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
4261 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
4262 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
4263 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
4264 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
4265 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
4266 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
4267 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
4268 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
4269 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
4270 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
4272 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
4273 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
4274 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
4275 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
4276 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
4277 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
4278 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
4279 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
4280 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
4281 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
4282 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
4284 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
4285 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
4286 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
4287 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
4288 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
4289 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
4290 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
4291 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
4292 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
4293 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
4294 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
4295 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
4296 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
4297 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
4298 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
4299 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
4300 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
4301 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
4302 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
4303 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
4304 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
4305 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
4306 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
4307 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
4308 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
4309 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
4310 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
4311 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
4312 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
4313 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
4314 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
4315 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
4316 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
4317 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
4318 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
4319 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
4320 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
4321 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
4322 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
4323 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
4324 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
4325 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
4326 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
4327 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
4328 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
4329 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
4330 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
4331 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
4332 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
4333 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
4334 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
4335 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
4336 {{ 1,
false, 6, 0 }} },
4337 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
4338 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
4339 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
4340 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
4341 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
4342 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
4343 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
4344 {{ 1,
false, 5, 0 }} },
4345 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
4346 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
4347 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
4348 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
4349 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
4350 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
4351 { 2,
false, 5, 0 }} },
4352 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
4353 { 2,
false, 6, 0 }} },
4354 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
4355 { 3,
false, 5, 0 }} },
4356 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
4357 { 3,
false, 6, 0 }} },
4358 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
4359 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
4360 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
4361 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
4362 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
4363 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
4364 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
4365 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
4366 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
4367 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
4368 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
4369 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
4370 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
4371 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
4372 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
4373 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
4374 {{ 2,
false, 4, 0 },
4375 { 3,
false, 5, 0 }} },
4376 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
4377 {{ 2,
false, 4, 0 },
4378 { 3,
false, 5, 0 }} },
4379 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
4380 {{ 2,
false, 4, 0 },
4381 { 3,
false, 5, 0 }} },
4382 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
4383 {{ 2,
false, 4, 0 },
4384 { 3,
false, 5, 0 }} },
4385 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
4386 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
4387 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
4388 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
4389 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
4390 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
4391 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
4392 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
4393 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
4394 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
4395 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
4396 { 2,
false, 5, 0 }} },
4397 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
4398 { 2,
false, 6, 0 }} },
4399 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
4400 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
4401 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
4402 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
4403 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
4404 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
4405 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
4406 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
4407 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
4408 {{ 1,
false, 4, 0 }} },
4409 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
4410 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
4411 {{ 1,
false, 4, 0 }} },
4412 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
4413 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
4414 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
4415 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
4416 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
4417 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
4418 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
4419 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
4420 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
4421 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
4422 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
4423 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
4424 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
4425 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
4426 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
4427 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
4428 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
4429 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
4430 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
4431 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
4432 {{ 3,
false, 1, 0 }} },
4433 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
4434 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
4435 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
4436 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
4437 {{ 3,
false, 1, 0 }} },
4438 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
4439 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
4440 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
4441 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
4442 {{ 3,
false, 1, 0 }} },
4444 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
4445 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
4446 {{ 2,
false, 2, 0 }} },
4447 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
4448 {{ 3,
false, 2, 0 }} },
4449 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
4450 {{ 3,
false, 2, 0 }} },
4451 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
4452 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
4453 {{ 2,
false, 2, 0 }} },
4454 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
4455 {{ 3,
false, 2, 0 }} },
4456 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
4457 {{ 3,
false, 2, 0 }} },
4458 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
4459 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
4460 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
4461 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
4462 {{ 3,
false, 3, 0 }} },
4463 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
4464 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
4465 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
4466 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
4467 {{ 3,
false, 3, 0 }} },
4472 static const bool SortOnce =
4475 return LHS.BuiltinID < RHS.BuiltinID;
4481 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
4482 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
4487 for (
const ArgInfo &A : F->Infos) {
4489 if (A.BitWidth == 0)
4492 int32_t
Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
4493 int32_t
Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
4495 Error |= BuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
4497 unsigned M = 1 << A.Align;
4500 Error |= BuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
4501 Error |= BuiltinConstantArgMultiple(TheCall, A.OpNum, M);
4507 bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
4509 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
4512 bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
4515 switch (BuiltinID) {
4519 case LoongArch::BI__builtin_loongarch_cacop_d:
4520 case LoongArch::BI__builtin_loongarch_cacop_w: {
4521 BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
4522 BuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12), llvm::maxIntN(12));
4525 case LoongArch::BI__builtin_loongarch_break:
4526 case LoongArch::BI__builtin_loongarch_dbar:
4527 case LoongArch::BI__builtin_loongarch_ibar:
4528 case LoongArch::BI__builtin_loongarch_syscall:
4530 return BuiltinConstantArgRange(TheCall, 0, 0, 32767);
4531 case LoongArch::BI__builtin_loongarch_csrrd_w:
4532 case LoongArch::BI__builtin_loongarch_csrrd_d:
4533 return BuiltinConstantArgRange(TheCall, 0, 0, 16383);
4534 case LoongArch::BI__builtin_loongarch_csrwr_w:
4535 case LoongArch::BI__builtin_loongarch_csrwr_d:
4536 return BuiltinConstantArgRange(TheCall, 1, 0, 16383);
4537 case LoongArch::BI__builtin_loongarch_csrxchg_w:
4538 case LoongArch::BI__builtin_loongarch_csrxchg_d:
4539 return BuiltinConstantArgRange(TheCall, 2, 0, 16383);
4540 case LoongArch::BI__builtin_loongarch_lddir_d:
4541 case LoongArch::BI__builtin_loongarch_ldpte_d:
4542 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4543 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
4544 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
4545 return BuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
4548 case LoongArch::BI__builtin_lsx_vbitclri_b:
4549 case LoongArch::BI__builtin_lsx_vbitrevi_b:
4550 case LoongArch::BI__builtin_lsx_vbitseti_b:
4551 case LoongArch::BI__builtin_lsx_vsat_b:
4552 case LoongArch::BI__builtin_lsx_vsat_bu:
4553 case LoongArch::BI__builtin_lsx_vslli_b:
4554 case LoongArch::BI__builtin_lsx_vsrai_b:
4555 case LoongArch::BI__builtin_lsx_vsrari_b:
4556 case LoongArch::BI__builtin_lsx_vsrli_b:
4557 case LoongArch::BI__builtin_lsx_vsllwil_h_b:
4558 case LoongArch::BI__builtin_lsx_vsllwil_hu_bu:
4559 case LoongArch::BI__builtin_lsx_vrotri_b:
4560 case LoongArch::BI__builtin_lsx_vsrlri_b:
4561 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4562 case LoongArch::BI__builtin_lsx_vbitclri_h:
4563 case LoongArch::BI__builtin_lsx_vbitrevi_h:
4564 case LoongArch::BI__builtin_lsx_vbitseti_h:
4565 case LoongArch::BI__builtin_lsx_vsat_h:
4566 case LoongArch::BI__builtin_lsx_vsat_hu:
4567 case LoongArch::BI__builtin_lsx_vslli_h:
4568 case LoongArch::BI__builtin_lsx_vsrai_h:
4569 case LoongArch::BI__builtin_lsx_vsrari_h:
4570 case LoongArch::BI__builtin_lsx_vsrli_h:
4571 case LoongArch::BI__builtin_lsx_vsllwil_w_h:
4572 case LoongArch::BI__builtin_lsx_vsllwil_wu_hu:
4573 case LoongArch::BI__builtin_lsx_vrotri_h:
4574 case LoongArch::BI__builtin_lsx_vsrlri_h:
4575 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4576 case LoongArch::BI__builtin_lsx_vssrarni_b_h:
4577 case LoongArch::BI__builtin_lsx_vssrarni_bu_h:
4578 case LoongArch::BI__builtin_lsx_vssrani_b_h:
4579 case LoongArch::BI__builtin_lsx_vssrani_bu_h:
4580 case LoongArch::BI__builtin_lsx_vsrarni_b_h:
4581 case LoongArch::BI__builtin_lsx_vsrlni_b_h:
4582 case LoongArch::BI__builtin_lsx_vsrlrni_b_h:
4583 case LoongArch::BI__builtin_lsx_vssrlni_b_h:
4584 case LoongArch::BI__builtin_lsx_vssrlni_bu_h:
4585 case LoongArch::BI__builtin_lsx_vssrlrni_b_h:
4586 case LoongArch::BI__builtin_lsx_vssrlrni_bu_h:
4587 case LoongArch::BI__builtin_lsx_vsrani_b_h:
4588 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4589 case LoongArch::BI__builtin_lsx_vslei_bu:
4590 case LoongArch::BI__builtin_lsx_vslei_hu:
4591 case LoongArch::BI__builtin_lsx_vslei_wu:
4592 case LoongArch::BI__builtin_lsx_vslei_du:
4593 case LoongArch::BI__builtin_lsx_vslti_bu:
4594 case LoongArch::BI__builtin_lsx_vslti_hu:
4595 case LoongArch::BI__builtin_lsx_vslti_wu:
4596 case LoongArch::BI__builtin_lsx_vslti_du:
4597 case LoongArch::BI__builtin_lsx_vmaxi_bu:
4598 case LoongArch::BI__builtin_lsx_vmaxi_hu:
4599 case LoongArch::BI__builtin_lsx_vmaxi_wu:
4600 case LoongArch::BI__builtin_lsx_vmaxi_du:
4601 case LoongArch::BI__builtin_lsx_vmini_bu:
4602 case LoongArch::BI__builtin_lsx_vmini_hu:
4603 case LoongArch::BI__builtin_lsx_vmini_wu:
4604 case LoongArch::BI__builtin_lsx_vmini_du:
4605 case LoongArch::BI__builtin_lsx_vaddi_bu:
4606 case LoongArch::BI__builtin_lsx_vaddi_hu:
4607 case LoongArch::BI__builtin_lsx_vaddi_wu:
4608 case LoongArch::BI__builtin_lsx_vaddi_du:
4609 case LoongArch::BI__builtin_lsx_vbitclri_w:
4610 case LoongArch::BI__builtin_lsx_vbitrevi_w:
4611 case LoongArch::BI__builtin_lsx_vbitseti_w:
4612 case LoongArch::BI__builtin_lsx_vsat_w:
4613 case LoongArch::BI__builtin_lsx_vsat_wu:
4614 case LoongArch::BI__builtin_lsx_vslli_w:
4615 case LoongArch::BI__builtin_lsx_vsrai_w:
4616 case LoongArch::BI__builtin_lsx_vsrari_w:
4617 case LoongArch::BI__builtin_lsx_vsrli_w:
4618 case LoongArch::BI__builtin_lsx_vsllwil_d_w:
4619 case LoongArch::BI__builtin_lsx_vsllwil_du_wu:
4620 case LoongArch::BI__builtin_lsx_vsrlri_w:
4621 case LoongArch::BI__builtin_lsx_vrotri_w:
4622 case LoongArch::BI__builtin_lsx_vsubi_bu:
4623 case LoongArch::BI__builtin_lsx_vsubi_hu:
4624 case LoongArch::BI__builtin_lsx_vbsrl_v:
4625 case LoongArch::BI__builtin_lsx_vbsll_v:
4626 case LoongArch::BI__builtin_lsx_vsubi_wu:
4627 case LoongArch::BI__builtin_lsx_vsubi_du:
4628 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4629 case LoongArch::BI__builtin_lsx_vssrarni_h_w:
4630 case LoongArch::BI__builtin_lsx_vssrarni_hu_w:
4631 case LoongArch::BI__builtin_lsx_vssrani_h_w:
4632 case LoongArch::BI__builtin_lsx_vssrani_hu_w:
4633 case LoongArch::BI__builtin_lsx_vsrarni_h_w:
4634 case LoongArch::BI__builtin_lsx_vsrani_h_w:
4635 case LoongArch::BI__builtin_lsx_vfrstpi_b:
4636 case LoongArch::BI__builtin_lsx_vfrstpi_h:
4637 case LoongArch::BI__builtin_lsx_vsrlni_h_w:
4638 case LoongArch::BI__builtin_lsx_vsrlrni_h_w:
4639 case LoongArch::BI__builtin_lsx_vssrlni_h_w:
4640 case LoongArch::BI__builtin_lsx_vssrlni_hu_w:
4641 case LoongArch::BI__builtin_lsx_vssrlrni_h_w:
4642 case LoongArch::BI__builtin_lsx_vssrlrni_hu_w:
4643 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4644 case LoongArch::BI__builtin_lsx_vbitclri_d:
4645 case LoongArch::BI__builtin_lsx_vbitrevi_d:
4646 case LoongArch::BI__builtin_lsx_vbitseti_d:
4647 case LoongArch::BI__builtin_lsx_vsat_d:
4648 case LoongArch::BI__builtin_lsx_vsat_du:
4649 case LoongArch::BI__builtin_lsx_vslli_d:
4650 case LoongArch::BI__builtin_lsx_vsrai_d:
4651 case LoongArch::BI__builtin_lsx_vsrli_d:
4652 case LoongArch::BI__builtin_lsx_vsrari_d:
4653 case LoongArch::BI__builtin_lsx_vrotri_d:
4654 case LoongArch::BI__builtin_lsx_vsrlri_d:
4655 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4656 case LoongArch::BI__builtin_lsx_vssrarni_w_d:
4657 case LoongArch::BI__builtin_lsx_vssrarni_wu_d:
4658 case LoongArch::BI__builtin_lsx_vssrani_w_d:
4659 case LoongArch::BI__builtin_lsx_vssrani_wu_d:
4660 case LoongArch::BI__builtin_lsx_vsrarni_w_d:
4661 case LoongArch::BI__builtin_lsx_vsrlni_w_d:
4662 case LoongArch::BI__builtin_lsx_vsrlrni_w_d:
4663 case LoongArch::BI__builtin_lsx_vssrlni_w_d:
4664 case LoongArch::BI__builtin_lsx_vssrlni_wu_d:
4665 case LoongArch::BI__builtin_lsx_vssrlrni_w_d:
4666 case LoongArch::BI__builtin_lsx_vssrlrni_wu_d:
4667 case LoongArch::BI__builtin_lsx_vsrani_w_d:
4668 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4669 case LoongArch::BI__builtin_lsx_vssrarni_d_q:
4670 case LoongArch::BI__builtin_lsx_vssrarni_du_q:
4671 case LoongArch::BI__builtin_lsx_vssrani_d_q:
4672 case LoongArch::BI__builtin_lsx_vssrani_du_q:
4673 case LoongArch::BI__builtin_lsx_vsrarni_d_q:
4674 case LoongArch::BI__builtin_lsx_vssrlni_d_q:
4675 case LoongArch::BI__builtin_lsx_vssrlni_du_q:
4676 case LoongArch::BI__builtin_lsx_vssrlrni_d_q:
4677 case LoongArch::BI__builtin_lsx_vssrlrni_du_q:
4678 case LoongArch::BI__builtin_lsx_vsrani_d_q:
4679 case LoongArch::BI__builtin_lsx_vsrlrni_d_q:
4680 case LoongArch::BI__builtin_lsx_vsrlni_d_q:
4681 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4682 case LoongArch::BI__builtin_lsx_vseqi_b:
4683 case LoongArch::BI__builtin_lsx_vseqi_h:
4684 case LoongArch::BI__builtin_lsx_vseqi_w:
4685 case LoongArch::BI__builtin_lsx_vseqi_d:
4686 case LoongArch::BI__builtin_lsx_vslti_b:
4687 case LoongArch::BI__builtin_lsx_vslti_h:
4688 case LoongArch::BI__builtin_lsx_vslti_w:
4689 case LoongArch::BI__builtin_lsx_vslti_d:
4690 case LoongArch::BI__builtin_lsx_vslei_b:
4691 case LoongArch::BI__builtin_lsx_vslei_h:
4692 case LoongArch::BI__builtin_lsx_vslei_w:
4693 case LoongArch::BI__builtin_lsx_vslei_d:
4694 case LoongArch::BI__builtin_lsx_vmaxi_b:
4695 case LoongArch::BI__builtin_lsx_vmaxi_h:
4696 case LoongArch::BI__builtin_lsx_vmaxi_w:
4697 case LoongArch::BI__builtin_lsx_vmaxi_d:
4698 case LoongArch::BI__builtin_lsx_vmini_b:
4699 case LoongArch::BI__builtin_lsx_vmini_h:
4700 case LoongArch::BI__builtin_lsx_vmini_w:
4701 case LoongArch::BI__builtin_lsx_vmini_d:
4702 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4703 case LoongArch::BI__builtin_lsx_vandi_b:
4704 case LoongArch::BI__builtin_lsx_vnori_b:
4705 case LoongArch::BI__builtin_lsx_vori_b:
4706 case LoongArch::BI__builtin_lsx_vshuf4i_b:
4707 case LoongArch::BI__builtin_lsx_vshuf4i_h:
4708 case LoongArch::BI__builtin_lsx_vshuf4i_w:
4709 case LoongArch::BI__builtin_lsx_vxori_b:
4710 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4711 case LoongArch::BI__builtin_lsx_vbitseli_b:
4712 case LoongArch::BI__builtin_lsx_vshuf4i_d:
4713 case LoongArch::BI__builtin_lsx_vextrins_b:
4714 case LoongArch::BI__builtin_lsx_vextrins_h:
4715 case LoongArch::BI__builtin_lsx_vextrins_w:
4716 case LoongArch::BI__builtin_lsx_vextrins_d:
4717 case LoongArch::BI__builtin_lsx_vpermi_w:
4718 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4719 case LoongArch::BI__builtin_lsx_vpickve2gr_b:
4720 case LoongArch::BI__builtin_lsx_vpickve2gr_bu:
4721 case LoongArch::BI__builtin_lsx_vreplvei_b:
4722 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4723 case LoongArch::BI__builtin_lsx_vinsgr2vr_b:
4724 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4725 case LoongArch::BI__builtin_lsx_vpickve2gr_h:
4726 case LoongArch::BI__builtin_lsx_vpickve2gr_hu:
4727 case LoongArch::BI__builtin_lsx_vreplvei_h:
4728 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4729 case LoongArch::BI__builtin_lsx_vinsgr2vr_h:
4730 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4731 case LoongArch::BI__builtin_lsx_vpickve2gr_w:
4732 case LoongArch::BI__builtin_lsx_vpickve2gr_wu:
4733 case LoongArch::BI__builtin_lsx_vreplvei_w:
4734 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4735 case LoongArch::BI__builtin_lsx_vinsgr2vr_w:
4736 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4737 case LoongArch::BI__builtin_lsx_vpickve2gr_d:
4738 case LoongArch::BI__builtin_lsx_vpickve2gr_du:
4739 case LoongArch::BI__builtin_lsx_vreplvei_d:
4740 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4741 case LoongArch::BI__builtin_lsx_vinsgr2vr_d:
4742 return BuiltinConstantArgRange(TheCall, 2, 0, 1);
4743 case LoongArch::BI__builtin_lsx_vstelm_b:
4744 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4745 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4746 case LoongArch::BI__builtin_lsx_vstelm_h:
4747 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4748 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4749 case LoongArch::BI__builtin_lsx_vstelm_w:
4750 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4751 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4752 case LoongArch::BI__builtin_lsx_vstelm_d:
4753 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4754 BuiltinConstantArgRange(TheCall, 3, 0, 1);
4755 case LoongArch::BI__builtin_lsx_vldrepl_b:
4756 case LoongArch::BI__builtin_lsx_vld:
4757 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4758 case LoongArch::BI__builtin_lsx_vldrepl_h:
4759 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4760 case LoongArch::BI__builtin_lsx_vldrepl_w:
4761 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4762 case LoongArch::BI__builtin_lsx_vldrepl_d:
4763 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4764 case LoongArch::BI__builtin_lsx_vst:
4765 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4766 case LoongArch::BI__builtin_lsx_vldi:
4767 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4768 case LoongArch::BI__builtin_lsx_vrepli_b:
4769 case LoongArch::BI__builtin_lsx_vrepli_h:
4770 case LoongArch::BI__builtin_lsx_vrepli_w:
4771 case LoongArch::BI__builtin_lsx_vrepli_d:
4772 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
4775 case LoongArch::BI__builtin_lasx_xvbitclri_b:
4776 case LoongArch::BI__builtin_lasx_xvbitrevi_b:
4777 case LoongArch::BI__builtin_lasx_xvbitseti_b:
4778 case LoongArch::BI__builtin_lasx_xvsat_b:
4779 case LoongArch::BI__builtin_lasx_xvsat_bu:
4780 case LoongArch::BI__builtin_lasx_xvslli_b:
4781 case LoongArch::BI__builtin_lasx_xvsrai_b:
4782 case LoongArch::BI__builtin_lasx_xvsrari_b:
4783 case LoongArch::BI__builtin_lasx_xvsrli_b:
4784 case LoongArch::BI__builtin_lasx_xvsllwil_h_b:
4785 case LoongArch::BI__builtin_lasx_xvsllwil_hu_bu:
4786 case LoongArch::BI__builtin_lasx_xvrotri_b:
4787 case LoongArch::BI__builtin_lasx_xvsrlri_b:
4788 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4789 case LoongArch::BI__builtin_lasx_xvbitclri_h:
4790 case LoongArch::BI__builtin_lasx_xvbitrevi_h:
4791 case LoongArch::BI__builtin_lasx_xvbitseti_h:
4792 case LoongArch::BI__builtin_lasx_xvsat_h:
4793 case LoongArch::BI__builtin_lasx_xvsat_hu:
4794 case LoongArch::BI__builtin_lasx_xvslli_h:
4795 case LoongArch::BI__builtin_lasx_xvsrai_h:
4796 case LoongArch::BI__builtin_lasx_xvsrari_h:
4797 case LoongArch::BI__builtin_lasx_xvsrli_h:
4798 case LoongArch::BI__builtin_lasx_xvsllwil_w_h:
4799 case LoongArch::BI__builtin_lasx_xvsllwil_wu_hu:
4800 case LoongArch::BI__builtin_lasx_xvrotri_h:
4801 case LoongArch::BI__builtin_lasx_xvsrlri_h:
4802 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4803 case LoongArch::BI__builtin_lasx_xvssrarni_b_h:
4804 case LoongArch::BI__builtin_lasx_xvssrarni_bu_h:
4805 case LoongArch::BI__builtin_lasx_xvssrani_b_h:
4806 case LoongArch::BI__builtin_lasx_xvssrani_bu_h:
4807 case LoongArch::BI__builtin_lasx_xvsrarni_b_h:
4808 case LoongArch::BI__builtin_lasx_xvsrlni_b_h:
4809 case LoongArch::BI__builtin_lasx_xvsrlrni_b_h:
4810 case LoongArch::BI__builtin_lasx_xvssrlni_b_h:
4811 case LoongArch::BI__builtin_lasx_xvssrlni_bu_h:
4812 case LoongArch::BI__builtin_lasx_xvssrlrni_b_h:
4813 case LoongArch::BI__builtin_lasx_xvssrlrni_bu_h:
4814 case LoongArch::BI__builtin_lasx_xvsrani_b_h:
4815 return BuiltinConstantArgRange(TheCall, 2, 0, 15);
4816 case LoongArch::BI__builtin_lasx_xvslei_bu:
4817 case LoongArch::BI__builtin_lasx_xvslei_hu:
4818 case LoongArch::BI__builtin_lasx_xvslei_wu:
4819 case LoongArch::BI__builtin_lasx_xvslei_du:
4820 case LoongArch::BI__builtin_lasx_xvslti_bu:
4821 case LoongArch::BI__builtin_lasx_xvslti_hu:
4822 case LoongArch::BI__builtin_lasx_xvslti_wu:
4823 case LoongArch::BI__builtin_lasx_xvslti_du:
4824 case LoongArch::BI__builtin_lasx_xvmaxi_bu:
4825 case LoongArch::BI__builtin_lasx_xvmaxi_hu:
4826 case LoongArch::BI__builtin_lasx_xvmaxi_wu:
4827 case LoongArch::BI__builtin_lasx_xvmaxi_du:
4828 case LoongArch::BI__builtin_lasx_xvmini_bu:
4829 case LoongArch::BI__builtin_lasx_xvmini_hu:
4830 case LoongArch::BI__builtin_lasx_xvmini_wu:
4831 case LoongArch::BI__builtin_lasx_xvmini_du:
4832 case LoongArch::BI__builtin_lasx_xvaddi_bu:
4833 case LoongArch::BI__builtin_lasx_xvaddi_hu:
4834 case LoongArch::BI__builtin_lasx_xvaddi_wu:
4835 case LoongArch::BI__builtin_lasx_xvaddi_du:
4836 case LoongArch::BI__builtin_lasx_xvbitclri_w:
4837 case LoongArch::BI__builtin_lasx_xvbitrevi_w:
4838 case LoongArch::BI__builtin_lasx_xvbitseti_w:
4839 case LoongArch::BI__builtin_lasx_xvsat_w:
4840 case LoongArch::BI__builtin_lasx_xvsat_wu:
4841 case LoongArch::BI__builtin_lasx_xvslli_w:
4842 case LoongArch::BI__builtin_lasx_xvsrai_w:
4843 case LoongArch::BI__builtin_lasx_xvsrari_w:
4844 case LoongArch::BI__builtin_lasx_xvsrli_w:
4845 case LoongArch::BI__builtin_lasx_xvsllwil_d_w:
4846 case LoongArch::BI__builtin_lasx_xvsllwil_du_wu:
4847 case LoongArch::BI__builtin_lasx_xvsrlri_w:
4848 case LoongArch::BI__builtin_lasx_xvrotri_w:
4849 case LoongArch::BI__builtin_lasx_xvsubi_bu:
4850 case LoongArch::BI__builtin_lasx_xvsubi_hu:
4851 case LoongArch::BI__builtin_lasx_xvsubi_wu:
4852 case LoongArch::BI__builtin_lasx_xvsubi_du:
4853 case LoongArch::BI__builtin_lasx_xvbsrl_v:
4854 case LoongArch::BI__builtin_lasx_xvbsll_v:
4855 return BuiltinConstantArgRange(TheCall, 1, 0, 31);
4856 case LoongArch::BI__builtin_lasx_xvssrarni_h_w:
4857 case LoongArch::BI__builtin_lasx_xvssrarni_hu_w:
4858 case LoongArch::BI__builtin_lasx_xvssrani_h_w:
4859 case LoongArch::BI__builtin_lasx_xvssrani_hu_w:
4860 case LoongArch::BI__builtin_lasx_xvsrarni_h_w:
4861 case LoongArch::BI__builtin_lasx_xvsrani_h_w:
4862 case LoongArch::BI__builtin_lasx_xvfrstpi_b:
4863 case LoongArch::BI__builtin_lasx_xvfrstpi_h:
4864 case LoongArch::BI__builtin_lasx_xvsrlni_h_w:
4865 case LoongArch::BI__builtin_lasx_xvsrlrni_h_w:
4866 case LoongArch::BI__builtin_lasx_xvssrlni_h_w:
4867 case LoongArch::BI__builtin_lasx_xvssrlni_hu_w:
4868 case LoongArch::BI__builtin_lasx_xvssrlrni_h_w:
4869 case LoongArch::BI__builtin_lasx_xvssrlrni_hu_w:
4870 return BuiltinConstantArgRange(TheCall, 2, 0, 31);
4871 case LoongArch::BI__builtin_lasx_xvbitclri_d:
4872 case LoongArch::BI__builtin_lasx_xvbitrevi_d:
4873 case LoongArch::BI__builtin_lasx_xvbitseti_d:
4874 case LoongArch::BI__builtin_lasx_xvsat_d:
4875 case LoongArch::BI__builtin_lasx_xvsat_du:
4876 case LoongArch::BI__builtin_lasx_xvslli_d:
4877 case LoongArch::BI__builtin_lasx_xvsrai_d:
4878 case LoongArch::BI__builtin_lasx_xvsrli_d:
4879 case LoongArch::BI__builtin_lasx_xvsrari_d:
4880 case LoongArch::BI__builtin_lasx_xvrotri_d:
4881 case LoongArch::BI__builtin_lasx_xvsrlri_d:
4882 return BuiltinConstantArgRange(TheCall, 1, 0, 63);
4883 case LoongArch::BI__builtin_lasx_xvssrarni_w_d:
4884 case LoongArch::BI__builtin_lasx_xvssrarni_wu_d:
4885 case LoongArch::BI__builtin_lasx_xvssrani_w_d:
4886 case LoongArch::BI__builtin_lasx_xvssrani_wu_d:
4887 case LoongArch::BI__builtin_lasx_xvsrarni_w_d:
4888 case LoongArch::BI__builtin_lasx_xvsrlni_w_d:
4889 case LoongArch::BI__builtin_lasx_xvsrlrni_w_d:
4890 case LoongArch::BI__builtin_lasx_xvssrlni_w_d:
4891 case LoongArch::BI__builtin_lasx_xvssrlni_wu_d:
4892 case LoongArch::BI__builtin_lasx_xvssrlrni_w_d:
4893 case LoongArch::BI__builtin_lasx_xvssrlrni_wu_d:
4894 case LoongArch::BI__builtin_lasx_xvsrani_w_d:
4895 return BuiltinConstantArgRange(TheCall, 2, 0, 63);
4896 case LoongArch::BI__builtin_lasx_xvssrarni_d_q:
4897 case LoongArch::BI__builtin_lasx_xvssrarni_du_q:
4898 case LoongArch::BI__builtin_lasx_xvssrani_d_q:
4899 case LoongArch::BI__builtin_lasx_xvssrani_du_q:
4900 case LoongArch::BI__builtin_lasx_xvsrarni_d_q:
4901 case LoongArch::BI__builtin_lasx_xvssrlni_d_q:
4902 case LoongArch::BI__builtin_lasx_xvssrlni_du_q:
4903 case LoongArch::BI__builtin_lasx_xvssrlrni_d_q:
4904 case LoongArch::BI__builtin_lasx_xvssrlrni_du_q:
4905 case LoongArch::BI__builtin_lasx_xvsrani_d_q:
4906 case LoongArch::BI__builtin_lasx_xvsrlni_d_q:
4907 case LoongArch::BI__builtin_lasx_xvsrlrni_d_q:
4908 return BuiltinConstantArgRange(TheCall, 2, 0, 127);
4909 case LoongArch::BI__builtin_lasx_xvseqi_b:
4910 case LoongArch::BI__builtin_lasx_xvseqi_h:
4911 case LoongArch::BI__builtin_lasx_xvseqi_w:
4912 case LoongArch::BI__builtin_lasx_xvseqi_d:
4913 case LoongArch::BI__builtin_lasx_xvslti_b:
4914 case LoongArch::BI__builtin_lasx_xvslti_h:
4915 case LoongArch::BI__builtin_lasx_xvslti_w:
4916 case LoongArch::BI__builtin_lasx_xvslti_d:
4917 case LoongArch::BI__builtin_lasx_xvslei_b:
4918 case LoongArch::BI__builtin_lasx_xvslei_h:
4919 case LoongArch::BI__builtin_lasx_xvslei_w:
4920 case LoongArch::BI__builtin_lasx_xvslei_d:
4921 case LoongArch::BI__builtin_lasx_xvmaxi_b:
4922 case LoongArch::BI__builtin_lasx_xvmaxi_h:
4923 case LoongArch::BI__builtin_lasx_xvmaxi_w:
4924 case LoongArch::BI__builtin_lasx_xvmaxi_d:
4925 case LoongArch::BI__builtin_lasx_xvmini_b:
4926 case LoongArch::BI__builtin_lasx_xvmini_h:
4927 case LoongArch::BI__builtin_lasx_xvmini_w:
4928 case LoongArch::BI__builtin_lasx_xvmini_d:
4929 return BuiltinConstantArgRange(TheCall, 1, -16, 15);
4930 case LoongArch::BI__builtin_lasx_xvandi_b:
4931 case LoongArch::BI__builtin_lasx_xvnori_b:
4932 case LoongArch::BI__builtin_lasx_xvori_b:
4933 case LoongArch::BI__builtin_lasx_xvshuf4i_b:
4934 case LoongArch::BI__builtin_lasx_xvshuf4i_h:
4935 case LoongArch::BI__builtin_lasx_xvshuf4i_w:
4936 case LoongArch::BI__builtin_lasx_xvxori_b:
4937 case LoongArch::BI__builtin_lasx_xvpermi_d:
4938 return BuiltinConstantArgRange(TheCall, 1, 0, 255);
4939 case LoongArch::BI__builtin_lasx_xvbitseli_b:
4940 case LoongArch::BI__builtin_lasx_xvshuf4i_d:
4941 case LoongArch::BI__builtin_lasx_xvextrins_b:
4942 case LoongArch::BI__builtin_lasx_xvextrins_h:
4943 case LoongArch::BI__builtin_lasx_xvextrins_w:
4944 case LoongArch::BI__builtin_lasx_xvextrins_d:
4945 case LoongArch::BI__builtin_lasx_xvpermi_q:
4946 case LoongArch::BI__builtin_lasx_xvpermi_w:
4947 return BuiltinConstantArgRange(TheCall, 2, 0, 255);
4948 case LoongArch::BI__builtin_lasx_xvrepl128vei_b:
4949 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
4950 case LoongArch::BI__builtin_lasx_xvrepl128vei_h:
4951 case LoongArch::BI__builtin_lasx_xvpickve2gr_w:
4952 case LoongArch::BI__builtin_lasx_xvpickve2gr_wu:
4953 case LoongArch::BI__builtin_lasx_xvpickve_w_f:
4954 case LoongArch::BI__builtin_lasx_xvpickve_w:
4955 return BuiltinConstantArgRange(TheCall, 1, 0, 7);
4956 case LoongArch::BI__builtin_lasx_xvinsgr2vr_w:
4957 case LoongArch::BI__builtin_lasx_xvinsve0_w:
4958 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
4959 case LoongArch::BI__builtin_lasx_xvrepl128vei_w:
4960 case LoongArch::BI__builtin_lasx_xvpickve2gr_d:
4961 case LoongArch::BI__builtin_lasx_xvpickve2gr_du:
4962 case LoongArch::BI__builtin_lasx_xvpickve_d_f:
4963 case LoongArch::BI__builtin_lasx_xvpickve_d:
4964 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
4965 case LoongArch::BI__builtin_lasx_xvinsve0_d:
4966 case LoongArch::BI__builtin_lasx_xvinsgr2vr_d:
4967 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
4968 case LoongArch::BI__builtin_lasx_xvstelm_b:
4969 return BuiltinConstantArgRange(TheCall, 2, -128, 127) ||
4970 BuiltinConstantArgRange(TheCall, 3, 0, 31);
4971 case LoongArch::BI__builtin_lasx_xvstelm_h:
4972 return BuiltinConstantArgRange(TheCall, 2, -256, 254) ||
4973 BuiltinConstantArgRange(TheCall, 3, 0, 15);
4974 case LoongArch::BI__builtin_lasx_xvstelm_w:
4975 return BuiltinConstantArgRange(TheCall, 2, -512, 508) ||
4976 BuiltinConstantArgRange(TheCall, 3, 0, 7);
4977 case LoongArch::BI__builtin_lasx_xvstelm_d:
4978 return BuiltinConstantArgRange(TheCall, 2, -1024, 1016) ||
4979 BuiltinConstantArgRange(TheCall, 3, 0, 3);
4980 case LoongArch::BI__builtin_lasx_xvrepl128vei_d:
4981 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
4982 case LoongArch::BI__builtin_lasx_xvldrepl_b:
4983 case LoongArch::BI__builtin_lasx_xvld:
4984 return BuiltinConstantArgRange(TheCall, 1, -2048, 2047);
4985 case LoongArch::BI__builtin_lasx_xvldrepl_h:
4986 return BuiltinConstantArgRange(TheCall, 1, -2048, 2046);
4987 case LoongArch::BI__builtin_lasx_xvldrepl_w:
4988 return BuiltinConstantArgRange(TheCall, 1, -2048, 2044);
4989 case LoongArch::BI__builtin_lasx_xvldrepl_d:
4990 return BuiltinConstantArgRange(TheCall, 1, -2048, 2040);
4991 case LoongArch::BI__builtin_lasx_xvst:
4992 return BuiltinConstantArgRange(TheCall, 2, -2048, 2047);
4993 case LoongArch::BI__builtin_lasx_xvldi:
4994 return BuiltinConstantArgRange(TheCall, 0, -4096, 4095);
4995 case LoongArch::BI__builtin_lasx_xvrepli_b:
4996 case LoongArch::BI__builtin_lasx_xvrepli_h:
4997 case LoongArch::BI__builtin_lasx_xvrepli_w:
4998 case LoongArch::BI__builtin_lasx_xvrepli_d:
4999 return BuiltinConstantArgRange(TheCall, 0, -512, 511);
5004 bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
5005 unsigned BuiltinID,
CallExpr *TheCall) {
5006 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
5007 CheckMipsBuiltinArgument(BuiltinID, TheCall);
5010 bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
5013 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
5014 BuiltinID <= Mips::BI__builtin_mips_lwx) {
5016 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
5019 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
5020 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
5023 diag::err_mips_builtin_requires_dspr2);
5026 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
5027 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
5029 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
5044 bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
5045 unsigned i = 0, l = 0, u = 0, m = 0;
5046 switch (BuiltinID) {
5047 default:
return false;
5048 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
5049 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
5050 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
5051 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
5052 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
5053 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
5054 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
5058 case Mips::BI__builtin_msa_bclri_b:
5059 case Mips::BI__builtin_msa_bnegi_b:
5060 case Mips::BI__builtin_msa_bseti_b:
5061 case Mips::BI__builtin_msa_sat_s_b:
5062 case Mips::BI__builtin_msa_sat_u_b:
5063 case Mips::BI__builtin_msa_slli_b:
5064 case Mips::BI__builtin_msa_srai_b:
5065 case Mips::BI__builtin_msa_srari_b:
5066 case Mips::BI__builtin_msa_srli_b:
5067 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
5068 case Mips::BI__builtin_msa_binsli_b:
5069 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
5071 case Mips::BI__builtin_msa_bclri_h:
5072 case Mips::BI__builtin_msa_bnegi_h:
5073 case Mips::BI__builtin_msa_bseti_h:
5074 case Mips::BI__builtin_msa_sat_s_h:
5075 case Mips::BI__builtin_msa_sat_u_h:
5076 case Mips::BI__builtin_msa_slli_h:
5077 case Mips::BI__builtin_msa_srai_h:
5078 case Mips::BI__builtin_msa_srari_h:
5079 case Mips::BI__builtin_msa_srli_h:
5080 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
5081 case Mips::BI__builtin_msa_binsli_h:
5082 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
5086 case Mips::BI__builtin_msa_cfcmsa:
5087 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
5088 case Mips::BI__builtin_msa_clei_u_b:
5089 case Mips::BI__builtin_msa_clei_u_h:
5090 case Mips::BI__builtin_msa_clei_u_w:
5091 case Mips::BI__builtin_msa_clei_u_d:
5092 case Mips::BI__builtin_msa_clti_u_b:
5093 case Mips::BI__builtin_msa_clti_u_h:
5094 case Mips::BI__builtin_msa_clti_u_w:
5095 case Mips::BI__builtin_msa_clti_u_d:
5096 case Mips::BI__builtin_msa_maxi_u_b:
5097 case Mips::BI__builtin_msa_maxi_u_h:
5098 case Mips::BI__builtin_msa_maxi_u_w:
5099 case Mips::BI__builtin_msa_maxi_u_d:
5100 case Mips::BI__builtin_msa_mini_u_b:
5101 case Mips::BI__builtin_msa_mini_u_h:
5102 case Mips::BI__builtin_msa_mini_u_w:
5103 case Mips::BI__builtin_msa_mini_u_d:
5104 case Mips::BI__builtin_msa_addvi_b:
5105 case Mips::BI__builtin_msa_addvi_h:
5106 case Mips::BI__builtin_msa_addvi_w:
5107 case Mips::BI__builtin_msa_addvi_d:
5108 case Mips::BI__builtin_msa_bclri_w:
5109 case Mips::BI__builtin_msa_bnegi_w:
5110 case Mips::BI__builtin_msa_bseti_w:
5111 case Mips::BI__builtin_msa_sat_s_w:
5112 case Mips::BI__builtin_msa_sat_u_w:
5113 case Mips::BI__builtin_msa_slli_w:
5114 case Mips::BI__builtin_msa_srai_w:
5115 case Mips::BI__builtin_msa_srari_w:
5116 case Mips::BI__builtin_msa_srli_w:
5117 case Mips::BI__builtin_msa_srlri_w:
5118 case Mips::BI__builtin_msa_subvi_b:
5119 case Mips::BI__builtin_msa_subvi_h:
5120 case Mips::BI__builtin_msa_subvi_w:
5121 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
5122 case Mips::BI__builtin_msa_binsli_w:
5123 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
5125 case Mips::BI__builtin_msa_bclri_d:
5126 case Mips::BI__builtin_msa_bnegi_d:
5127 case Mips::BI__builtin_msa_bseti_d:
5128 case Mips::BI__builtin_msa_sat_s_d:
5129 case Mips::BI__builtin_msa_sat_u_d:
5130 case Mips::BI__builtin_msa_slli_d:
5131 case Mips::BI__builtin_msa_srai_d:
5132 case Mips::BI__builtin_msa_srari_d:
5133 case Mips::BI__builtin_msa_srli_d:
5134 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
5135 case Mips::BI__builtin_msa_binsli_d:
5136 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
5138 case Mips::BI__builtin_msa_ceqi_b:
5139 case Mips::BI__builtin_msa_ceqi_h:
5140 case Mips::BI__builtin_msa_ceqi_w:
5141 case Mips::BI__builtin_msa_ceqi_d:
5142 case Mips::BI__builtin_msa_clti_s_b:
5143 case Mips::BI__builtin_msa_clti_s_h:
5144 case Mips::BI__builtin_msa_clti_s_w:
5145 case Mips::BI__builtin_msa_clti_s_d:
5146 case Mips::BI__builtin_msa_clei_s_b:
5147 case Mips::BI__builtin_msa_clei_s_h:
5148 case Mips::BI__builtin_msa_clei_s_w:
5149 case Mips::BI__builtin_msa_clei_s_d:
5150 case Mips::BI__builtin_msa_maxi_s_b:
5151 case Mips::BI__builtin_msa_maxi_s_h:
5152 case Mips::BI__builtin_msa_maxi_s_w:
5153 case Mips::BI__builtin_msa_maxi_s_d:
5154 case Mips::BI__builtin_msa_mini_s_b:
5155 case Mips::BI__builtin_msa_mini_s_h:
5156 case Mips::BI__builtin_msa_mini_s_w:
5157 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
5159 case Mips::BI__builtin_msa_andi_b:
5160 case Mips::BI__builtin_msa_nori_b:
5161 case Mips::BI__builtin_msa_ori_b:
5162 case Mips::BI__builtin_msa_shf_b:
5163 case Mips::BI__builtin_msa_shf_h:
5164 case Mips::BI__builtin_msa_shf_w:
5165 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
5166 case Mips::BI__builtin_msa_bseli_b:
5167 case Mips::BI__builtin_msa_bmnzi_b:
5168 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
5171 case Mips::BI__builtin_msa_copy_s_b:
5172 case Mips::BI__builtin_msa_copy_u_b:
5173 case Mips::BI__builtin_msa_insve_b:
5174 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
5175 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
5177 case Mips::BI__builtin_msa_copy_s_h:
5178 case Mips::BI__builtin_msa_copy_u_h:
5179 case Mips::BI__builtin_msa_insve_h:
5180 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
5181 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
5183 case Mips::BI__builtin_msa_copy_s_w:
5184 case Mips::BI__builtin_msa_copy_u_w:
5185 case Mips::BI__builtin_msa_insve_w:
5186 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
5187 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
5189 case Mips::BI__builtin_msa_copy_s_d:
5190 case Mips::BI__builtin_msa_copy_u_d:
5191 case Mips::BI__builtin_msa_insve_d:
5192 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
5193 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
5196 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
5197 case Mips::BI__builtin_msa_ldi_h:
5198 case Mips::BI__builtin_msa_ldi_w:
5199 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
5200 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
5201 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
5202 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5203 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5204 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
5205 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
5206 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
5207 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
5208 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5209 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5210 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
5211 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
5215 return BuiltinConstantArgRange(TheCall, i, l, u);
5217 return BuiltinConstantArgRange(TheCall, i, l, u) ||
5218 BuiltinConstantArgMultiple(TheCall, i, m);
5229 bool RequireICE =
false;
5237 unsigned size = strtoul(Str, &
End, 10);
5238 assert(
End != Str &&
"Missing constant parameter constraint");
5241 return Context.
IntTy;
5245 unsigned size = strtoul(Str, &
End, 10);
5246 assert(
End != Str &&
"Missing PowerPC MMA type size");
5250 #define PPC_VECTOR_TYPE(typeName, Id, size) \
5251 case size: Type = Context.Id##Ty; break;
5252 #include "clang/Basic/PPCTypes.def"
5253 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
5255 bool CheckVectorArgs =
false;
5256 while (!CheckVectorArgs) {
5265 CheckVectorArgs =
true;
5273 return Context.
DecodeTypeStr(--Str, Context, Error, RequireICE,
true);
5279 switch (BuiltinID) {
5280 case PPC::BI__builtin_divde:
5281 case PPC::BI__builtin_divdeu:
5282 case PPC::BI__builtin_bpermd:
5283 case PPC::BI__builtin_pdepd:
5284 case PPC::BI__builtin_pextd:
5285 case PPC::BI__builtin_ppc_ldarx:
5286 case PPC::BI__builtin_ppc_stdcx:
5287 case PPC::BI__builtin_ppc_tdw:
5288 case PPC::BI__builtin_ppc_trapd:
5289 case PPC::BI__builtin_ppc_cmpeqb:
5290 case PPC::BI__builtin_ppc_setb:
5291 case PPC::BI__builtin_ppc_mulhd:
5292 case PPC::BI__builtin_ppc_mulhdu:
5293 case PPC::BI__builtin_ppc_maddhd:
5294 case PPC::BI__builtin_ppc_maddhdu:
5295 case PPC::BI__builtin_ppc_maddld:
5296 case PPC::BI__builtin_ppc_load8r:
5297 case PPC::BI__builtin_ppc_store8r:
5298 case PPC::BI__builtin_ppc_insert_exp:
5299 case PPC::BI__builtin_ppc_extract_sig:
5300 case PPC::BI__builtin_ppc_addex:
5301 case PPC::BI__builtin_darn:
5302 case PPC::BI__builtin_darn_raw:
5303 case PPC::BI__builtin_ppc_compare_and_swaplp:
5304 case PPC::BI__builtin_ppc_fetch_and_addlp:
5305 case PPC::BI__builtin_ppc_fetch_and_andlp:
5306 case PPC::BI__builtin_ppc_fetch_and_orlp:
5307 case PPC::BI__builtin_ppc_fetch_and_swaplp:
5317 bool Sema::ValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
5325 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5329 if (Result.isShiftedMask() || (~Result).isShiftedMask())
5333 diag::err_argument_not_contiguous_bit_field)
5337 bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5339 unsigned i = 0, l = 0, u = 0;
5344 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
5347 switch (BuiltinID) {
5348 default:
return false;
5349 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
5350 case PPC::BI__builtin_altivec_crypto_vshasigmad:
5351 return BuiltinConstantArgRange(TheCall, 1, 0, 1) ||
5352 BuiltinConstantArgRange(TheCall, 2, 0, 15);
5353 case PPC::BI__builtin_altivec_dss:
5354 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
5355 case PPC::BI__builtin_tbegin:
5356 case PPC::BI__builtin_tend:
5357 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5358 case PPC::BI__builtin_tsr:
5359 return BuiltinConstantArgRange(TheCall, 0, 0, 7);
5360 case PPC::BI__builtin_tabortwc:
5361 case PPC::BI__builtin_tabortdc:
5362 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5363 case PPC::BI__builtin_tabortwci:
5364 case PPC::BI__builtin_tabortdci:
5365 return BuiltinConstantArgRange(TheCall, 0, 0, 31) ||
5366 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5370 case PPC::BI__builtin_unpack_longdouble:
5371 if (BuiltinConstantArgRange(TheCall, 1, 0, 1))
5374 case PPC::BI__builtin_pack_longdouble:
5376 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
5379 case PPC::BI__builtin_altivec_dst:
5380 case PPC::BI__builtin_altivec_dstt:
5381 case PPC::BI__builtin_altivec_dstst:
5382 case PPC::BI__builtin_altivec_dststt:
5383 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
5384 case PPC::BI__builtin_vsx_xxpermdi:
5385 case PPC::BI__builtin_vsx_xxsldwi:
5386 return BuiltinVSX(TheCall);
5387 case PPC::BI__builtin_unpack_vector_int128:
5388 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5389 case PPC::BI__builtin_altivec_vgnb:
5390 return BuiltinConstantArgRange(TheCall, 1, 2, 7);
5391 case PPC::BI__builtin_vsx_xxeval:
5392 return BuiltinConstantArgRange(TheCall, 3, 0, 255);
5393 case PPC::BI__builtin_altivec_vsldbi:
5394 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5395 case PPC::BI__builtin_altivec_vsrdbi:
5396 return BuiltinConstantArgRange(TheCall, 2, 0, 7);
5397 case PPC::BI__builtin_vsx_xxpermx:
5398 return BuiltinConstantArgRange(TheCall, 3, 0, 7);
5399 case PPC::BI__builtin_ppc_tw:
5400 case PPC::BI__builtin_ppc_tdw:
5401 return BuiltinConstantArgRange(TheCall, 2, 1, 31);
5402 case PPC::BI__builtin_ppc_cmprb:
5403 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
5406 case PPC::BI__builtin_ppc_rlwnm:
5407 return ValueIsRunOfOnes(TheCall, 2);
5408 case PPC::BI__builtin_ppc_rlwimi:
5409 return BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
5410 ValueIsRunOfOnes(TheCall, 3);
5411 case PPC::BI__builtin_ppc_rldimi:
5412 return BuiltinConstantArgRange(TheCall, 2, 0, 63) ||
5413 ValueIsRunOfOnes(TheCall, 3);
5414 case PPC::BI__builtin_ppc_addex: {
5415 if (BuiltinConstantArgRange(TheCall, 2, 0, 3))
5425 case PPC::BI__builtin_ppc_mtfsb0:
5426 case PPC::BI__builtin_ppc_mtfsb1:
5427 return BuiltinConstantArgRange(TheCall, 0, 0, 31);
5428 case PPC::BI__builtin_ppc_mtfsf:
5429 return BuiltinConstantArgRange(TheCall, 0, 0, 255);
5430 case PPC::BI__builtin_ppc_mtfsfi:
5431 return BuiltinConstantArgRange(TheCall, 0, 0, 7) ||
5432 BuiltinConstantArgRange(TheCall, 1, 0, 15);
5433 case PPC::BI__builtin_ppc_alignx:
5434 return BuiltinConstantArgPower2(TheCall, 0);
5435 case PPC::BI__builtin_ppc_rdlam:
5436 return ValueIsRunOfOnes(TheCall, 2);
5437 case PPC::BI__builtin_vsx_ldrmb:
5438 case PPC::BI__builtin_vsx_strmb:
5439 return BuiltinConstantArgRange(TheCall, 1, 1, 16);
5440 case PPC::BI__builtin_altivec_vcntmbb:
5441 case PPC::BI__builtin_altivec_vcntmbh:
5442 case PPC::BI__builtin_altivec_vcntmbw:
5443 case PPC::BI__builtin_altivec_vcntmbd:
5444 return BuiltinConstantArgRange(TheCall, 1, 0, 1);
5445 case PPC::BI__builtin_vsx_xxgenpcvbm:
5446 case PPC::BI__builtin_vsx_xxgenpcvhm:
5447 case PPC::BI__builtin_vsx_xxgenpcvwm:
5448 case PPC::BI__builtin_vsx_xxgenpcvdm:
5449 return BuiltinConstantArgRange(TheCall, 1, 0, 3);
5450 case PPC::BI__builtin_ppc_test_data_class: {
5458 diag::err_ppc_invalid_test_data_class_type);
5459 return BuiltinConstantArgRange(TheCall, 1, 0, 127);
5461 case PPC::BI__builtin_ppc_maxfe:
5462 case PPC::BI__builtin_ppc_minfe:
5463 case PPC::BI__builtin_ppc_maxfl:
5464 case PPC::BI__builtin_ppc_minfl:
5465 case PPC::BI__builtin_ppc_maxfs:
5466 case PPC::BI__builtin_ppc_minfs: {
5468 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
5469 BuiltinID == PPC::BI__builtin_ppc_minfe))
5470 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
5475 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
5476 BuiltinID == PPC::BI__builtin_ppc_minfl)
5478 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
5479 BuiltinID == PPC::BI__builtin_ppc_minfs)
5481 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
5484 diag::err_typecheck_convert_incompatible)
5488 #define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
5489 case PPC::BI__builtin_##Name: \
5490 return BuiltinPPCMMACall(TheCall, BuiltinID, Types);
5491 #include "clang/Basic/BuiltinsPPC.def"
5493 return BuiltinConstantArgRange(TheCall, i, l, u);
5502 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
5503 #define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
5505 #include
"clang/Basic/PPCTypes.def"
5507 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
5523 for (
unsigned i = 1; i < TheCall->
getNumArgs(); ++i) {
5527 if (VecTyA ==
nullptr && VecTyB ==
nullptr)
5530 if (VecTyA && VecTyB) {
5531 bool retValue =
false;
5532 if (VecTyA->getElementType() != VecTyB->getElementType()) {
5536 diag::err_vec_builtin_incompatible_vector)
5541 if (VecTyA->getNumElements() != VecTyB->getNumElements()) {
5545 S->
Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
5557 S->
Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
5567 for (
unsigned i = 0; i < TheCall->
getNumArgs(); ++i) {
5569 if (Check(PassedType)) {
5572 ExpectedType, VecTyA->getNumElements(), VecTyA->getVectorKind());
5574 diag::err_typecheck_convert_incompatible)
5584 return !PassedType->hasFloatingRepresentation();
5587 checkAllFloatTypes);
5604 if (
const auto *VecTy = PassedType->getAs<
VectorType>())
5605 return VecTy->getElementType()->isDoubleType();
5614 return !PassedType->hasUnsignedIntegerRepresentation();
5617 checkAllUnsignedTypes);
5632 switch (BuiltinID) {
5633 case Builtin::BI__builtin_hlsl_elementwise_all:
5634 case Builtin::BI__builtin_hlsl_elementwise_any: {
5639 case Builtin::BI__builtin_hlsl_elementwise_clamp: {
5644 if (BuiltinElementwiseTernaryMath(
5650 case Builtin::BI__builtin_hlsl_dot: {
5655 if (BuiltinVectorToScalarMath(TheCall))
5661 case Builtin::BI__builtin_hlsl_elementwise_rcp: {
5664 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5668 case Builtin::BI__builtin_hlsl_elementwise_rsqrt:
5669 case Builtin::BI__builtin_hlsl_elementwise_frac: {
5672 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5676 case Builtin::BI__builtin_hlsl_elementwise_isinf: {
5679 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
5684 case Builtin::BI__builtin_hlsl_lerp: {
5689 if (BuiltinElementwiseTernaryMath(TheCall))
5695 case Builtin::BI__builtin_hlsl_mad: {
5700 if (BuiltinElementwiseTernaryMath(
5708 case Builtin::BI__builtin_elementwise_bitreverse: {
5713 case Builtin::BI__builtin_elementwise_ceil:
5714 case Builtin::BI__builtin_elementwise_cos:
5715 case Builtin::BI__builtin_elementwise_exp:
5716 case Builtin::BI__builtin_elementwise_exp2:
5717 case Builtin::BI__builtin_elementwise_floor:
5718 case Builtin::BI__builtin_elementwise_log:
5719 case Builtin::BI__builtin_elementwise_log2:
5720 case Builtin::BI__builtin_elementwise_log10:
5721 case Builtin::BI__builtin_elementwise_pow:
5722 case Builtin::BI__builtin_elementwise_roundeven:
5723 case Builtin::BI__builtin_elementwise_sin:
5724 case Builtin::BI__builtin_elementwise_sqrt:
5725 case Builtin::BI__builtin_elementwise_trunc: {
5734 bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
5737 unsigned OrderIndex, ScopeIndex;
5738 switch (BuiltinID) {
5739 case AMDGPU::BI__builtin_amdgcn_get_fpenv:
5740 case AMDGPU::BI__builtin_amdgcn_set_fpenv:
5742 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
5743 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
5744 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
5745 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
5749 case AMDGPU::BI__builtin_amdgcn_fence:
5758 auto ArgExpr = Arg.
get();
5761 if (!ArgExpr->EvaluateAsInt(ArgResult, Context))
5762 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
5763 << ArgExpr->getType();
5764 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
5768 if (!llvm::isValidAtomicOrderingCABI(Ord))
5769 return Diag(ArgExpr->getBeginLoc(),
5770 diag::warn_atomic_op_has_invalid_memory_order)
5771 << 0 << ArgExpr->getSourceRange();
5772 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
5773 case llvm::AtomicOrderingCABI::relaxed:
5774 case llvm::AtomicOrderingCABI::consume:
5775 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
5776 return Diag(ArgExpr->getBeginLoc(),
5777 diag::warn_atomic_op_has_invalid_memory_order)
5778 << 0 << ArgExpr->getSourceRange();
5780 case llvm::AtomicOrderingCABI::acquire:
5781 case llvm::AtomicOrderingCABI::release:
5782 case llvm::AtomicOrderingCABI::acq_rel:
5783 case llvm::AtomicOrderingCABI::seq_cst:
5787 Arg = TheCall->
getArg(ScopeIndex);
5788 ArgExpr = Arg.
get();
5791 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1, Context))
5792 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
5793 << ArgExpr->getType();
5798 bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
5807 if (BuiltinConstantArg(TheCall, ArgNum, Result))
5810 int64_t Val = Result.getSExtValue();
5811 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
5814 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
5820 assert((EGW == 128 || EGW == 256) &&
"EGW can only be 128 or 256 bits");
5826 unsigned MinElemCount = Info.
EC.getKnownMinValue();
5828 unsigned EGS = EGW / ElemSize;
5831 if (EGS <= MinElemCount)
5835 assert(EGS % MinElemCount == 0);
5836 unsigned VScaleFactor = EGS / MinElemCount;
5838 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
5839 std::string RequiredExt =
"zvl" + std::to_string(MinRequiredVLEN) +
"b";
5842 diag::err_riscv_type_requires_extension) <<
Type << RequiredExt;
5847 bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
5852 switch (BuiltinID) {
5855 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
5856 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
5857 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
5858 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
5859 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
5860 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
5861 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
5862 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
5863 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
5864 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
5865 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
5866 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
5867 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
5868 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
5869 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
5870 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
5871 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
5872 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
5873 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
5874 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
5875 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
5876 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
5877 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
5878 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
5879 case RISCVVector::BI__builtin_rvv_vmulh_vv:
5880 case RISCVVector::BI__builtin_rvv_vmulh_vx:
5881 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
5882 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
5883 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
5884 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
5885 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
5886 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
5887 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
5888 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
5889 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
5890 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
5891 case RISCVVector::BI__builtin_rvv_vsmul_vv:
5892 case RISCVVector::BI__builtin_rvv_vsmul_vx:
5893 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
5894 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
5895 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
5896 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
5897 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
5898 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
5899 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
5900 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
5901 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
5902 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
5908 diag::err_riscv_builtin_requires_extension)
5915 switch (BuiltinID) {
5916 case RISCVVector::BI__builtin_rvv_vsetvli:
5917 return BuiltinConstantArgRange(TheCall, 1, 0, 3) ||
5918 CheckRISCVLMUL(TheCall, 2);
5919 case RISCVVector::BI__builtin_rvv_vsetvlimax:
5920 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
5921 CheckRISCVLMUL(TheCall, 1);
5922 case RISCVVector::BI__builtin_rvv_vget_v: {
5933 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
5934 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
5935 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5937 case RISCVVector::BI__builtin_rvv_vset_v: {
5948 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
5950 return BuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
5953 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
5954 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
5955 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
5956 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
5961 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5963 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
5964 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
5967 BuiltinConstantArgRange(TheCall, 2, 0, 31);
5969 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
5970 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
5973 BuiltinConstantArgRange(TheCall, 1, 0, 31);
5975 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
5976 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
5977 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
5978 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
5979 case RISCVVector::BI__builtin_rvv_vaesef_vv:
5980 case RISCVVector::BI__builtin_rvv_vaesef_vs:
5981 case RISCVVector::BI__builtin_rvv_vaesem_vv:
5982 case RISCVVector::BI__builtin_rvv_vaesem_vs:
5983 case RISCVVector::BI__builtin_rvv_vaesz_vs:
5984 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
5985 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
5986 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
5987 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
5988 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
5989 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
5990 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
5991 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
5992 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
5993 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
5994 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
5995 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
5996 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
6002 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
6003 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
6004 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
6005 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
6006 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
6007 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
6014 if (ElemSize == 64 && !TI.
hasFeature(
"zvknhb"))
6016 diag::err_riscv_builtin_requires_extension)
6024 case RISCVVector::BI__builtin_rvv_sf_vc_i_se:
6026 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6027 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6028 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
6029 BuiltinConstantArgRange(TheCall, 3, -16, 15) ||
6030 CheckRISCVLMUL(TheCall, 5);
6031 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
6033 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6034 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6035 BuiltinConstantArgRange(TheCall, 3, -16, 15);
6036 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
6037 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
6039 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6040 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6041 BuiltinConstantArgRange(TheCall, 2, -16, 15);
6042 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
6043 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
6045 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6046 BuiltinConstantArgRange(TheCall, 2, -16, 15);
6047 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
6048 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
6049 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
6050 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
6051 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
6052 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
6054 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6055 BuiltinConstantArgRange(TheCall, 3, -16, 15);
6056 case RISCVVector::BI__builtin_rvv_sf_vc_x_se:
6058 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6059 BuiltinConstantArgRange(TheCall, 1, 0, 31) ||
6060 BuiltinConstantArgRange(TheCall, 2, 0, 31) ||
6061 CheckRISCVLMUL(TheCall, 5);
6062 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
6063 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
6065 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
6066 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
6068 return BuiltinConstantArgRange(TheCall, 0, 0, 3) ||
6069 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6070 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
6071 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
6072 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
6073 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
6075 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
6076 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
6077 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
6078 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
6080 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
6081 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
6082 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
6083 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
6084 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
6085 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
6086 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
6087 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
6089 return BuiltinConstantArgRange(TheCall, 0, 0, 3);
6090 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
6092 return BuiltinConstantArgRange(TheCall, 0, 0, 1) ||
6093 BuiltinConstantArgRange(TheCall, 1, 0, 31);
6094 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
6095 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
6096 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
6097 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
6098 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
6099 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
6101 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
6102 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
6104 return BuiltinConstantArgRange(TheCall, 0, 0, 1);
6106 case RISCV::BI__builtin_riscv_aes32dsi:
6107 case RISCV::BI__builtin_riscv_aes32dsmi:
6108 case RISCV::BI__builtin_riscv_aes32esi:
6109 case RISCV::BI__builtin_riscv_aes32esmi:
6110 case RISCV::BI__builtin_riscv_sm4ks:
6111 case RISCV::BI__builtin_riscv_sm4ed:
6112 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6114 case RISCV::BI__builtin_riscv_aes64ks1i:
6115 return BuiltinConstantArgRange(TheCall, 1, 0, 10);
6117 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
6118 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
6119 case RISCVVector::BI__builtin_rvv_vaadd_vv:
6120 case RISCVVector::BI__builtin_rvv_vaadd_vx:
6121 case RISCVVector::BI__builtin_rvv_vasubu_vv:
6122 case RISCVVector::BI__builtin_rvv_vasubu_vx:
6123 case RISCVVector::BI__builtin_rvv_vasub_vv:
6124 case RISCVVector::BI__builtin_rvv_vasub_vx:
6125 case RISCVVector::BI__builtin_rvv_vsmul_vv:
6126 case RISCVVector::BI__builtin_rvv_vsmul_vx:
6127 case RISCVVector::BI__builtin_rvv_vssra_vv:
6128 case RISCVVector::BI__builtin_rvv_vssra_vx:
6129 case RISCVVector::BI__builtin_rvv_vssrl_vv:
6130 case RISCVVector::BI__builtin_rvv_vssrl_vx:
6131 case RISCVVector::BI__builtin_rvv_vnclip_wv:
6132 case RISCVVector::BI__builtin_rvv_vnclip_wx:
6133 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
6134 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
6135 return BuiltinConstantArgRange(TheCall, 2, 0, 3);
6136 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
6137 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
6138 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
6139 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
6140 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
6141 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
6142 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
6143 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
6144 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
6145 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
6146 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
6147 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
6148 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
6149 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
6150 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
6151 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
6152 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
6153 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
6154 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
6155 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
6156 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
6157 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
6158 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
6159 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
6160 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
6161 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
6162 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
6163 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
6164 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
6165 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
6166 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
6167 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
6168 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
6169 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
6170 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
6171 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
6172 return BuiltinConstantArgRange(TheCall, 3, 0, 3);
6173 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
6174 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
6175 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
6176 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
6177 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
6178 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
6179 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
6180 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
6181 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
6182 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
6183 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
6184 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
6185 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
6186 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
6187 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
6188 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
6189 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
6190 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
6191 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
6192 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
6193 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
6194 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
6195 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
6196 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
6197 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
6198 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
6199 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
6200 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
6201 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
6202 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
6203 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
6204 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
6205 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
6206 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
6207 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
6208 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
6209 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
6210 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
6211 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
6212 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
6213 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
6214 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
6215 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
6216 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
6217 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
6218 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
6219 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
6220 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
6221 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
6222 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
6223 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
6224 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
6225 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
6226 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
6227 return BuiltinConstantArgRange(TheCall, 4, 0, 3);
6228 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
6229 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
6230 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
6231 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
6232 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
6233 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
6234 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
6235 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
6236 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
6237 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
6238 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
6239 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
6240 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
6241 return BuiltinConstantArgRange(TheCall, 1, 0, 4);
6242 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
6243 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
6244 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
6245 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
6246 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
6247 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
6248 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
6249 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
6250 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
6251 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
6252 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
6253 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
6254 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
6255 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
6256 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
6257 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
6258 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
6259 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
6260 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
6261 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
6262 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
6263 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
6264 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
6265 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
6266 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
6267 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
6268 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
6269 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
6270 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
6271 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
6272 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
6273 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
6274 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
6275 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
6276 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
6277 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
6278 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
6279 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
6280 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
6281 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
6282 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
6283 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
6284 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
6285 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
6286 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
6287 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
6288 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
6289 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
6290 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
6291 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
6292 return BuiltinConstantArgRange(TheCall, 2, 0, 4);
6293 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
6294 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
6295 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
6296 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
6297 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
6298 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
6299 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
6300 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
6301 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
6302 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
6303 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
6304 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
6305 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
6306 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
6307 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
6308 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
6309 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
6310 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
6311 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
6312 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
6313 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
6314 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
6315 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
6316 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
6317 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
6318 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
6319 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
6320 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
6321 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
6322 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
6323 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
6324 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
6325 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
6326 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
6327 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
6328 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
6329 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
6330 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
6331 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
6332 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
6333 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
6334 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
6335 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
6336 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
6337 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
6338 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
6339 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
6340 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
6341 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
6342 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
6343 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
6344 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
6345 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
6346 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
6347 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
6348 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
6349 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
6350 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
6351 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
6352 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
6353 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
6354 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
6355 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
6356 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
6357 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
6358 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
6359 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
6360 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
6361 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
6362 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
6363 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
6364 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
6365 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
6366 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
6367 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
6368 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
6369 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
6370 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
6371 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
6372 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
6373 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
6374 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
6375 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
6376 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
6377 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
6378 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
6379 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
6380 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
6381 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
6382 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
6383 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
6384 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
6385 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
6386 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
6387 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
6388 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
6389 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
6390 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
6391 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
6392 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
6393 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
6394 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
6395 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
6396 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
6397 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
6398 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
6399 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
6400 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
6401 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
6402 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
6403 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
6404 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
6405 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
6406 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
6407 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
6408 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
6409 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
6410 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
6411 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
6412 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
6413 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
6414 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
6415 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
6416 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
6417 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
6418 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
6419 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
6420 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
6421 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
6422 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
6423 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
6424 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
6425 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
6426 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
6427 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
6428 return BuiltinConstantArgRange(TheCall, 3, 0, 4);
6429 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
6430 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
6431 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
6432 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
6433 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
6434 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
6435 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
6436 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
6437 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
6438 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
6439 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
6440 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
6441 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
6442 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
6443 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
6444 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
6445 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
6446 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
6447 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
6448 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
6449 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
6450 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
6451 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
6452 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
6453 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
6454 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
6455 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
6456 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
6457 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
6458 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
6459 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
6460 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
6461 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
6462 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
6463 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
6464 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
6465 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
6466 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
6467 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
6468 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
6469 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
6470 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
6471 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
6472 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
6473 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
6474 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
6475 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
6476 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
6477 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
6478 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
6479 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
6480 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
6481 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
6482 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
6483 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
6484 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
6485 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
6486 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
6487 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
6488 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
6489 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
6490 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
6491 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
6492 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
6493 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
6494 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
6495 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
6496 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
6497 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
6498 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
6499 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
6500 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
6501 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
6502 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
6503 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
6504 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
6505 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
6506 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
6507 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
6508 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
6509 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
6510 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
6511 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
6512 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
6513 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
6514 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
6515 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
6516 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
6517 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
6518 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
6519 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
6520 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
6521 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
6522 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
6523 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
6524 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
6525 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
6526 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
6527 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
6528 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
6529 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
6530 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
6531 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
6532 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
6533 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
6534 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
6535 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
6536 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
6537 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
6538 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
6539 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
6540 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
6541 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
6542 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
6543 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
6544 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
6545 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
6546 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
6547 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
6548 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
6549 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
6550 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
6551 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
6552 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
6553 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
6554 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
6555 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
6556 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
6557 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
6558 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
6559 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
6560 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
6561 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
6562 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
6563 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
6564 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
6565 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
6566 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
6567 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
6568 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
6569 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
6570 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
6571 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
6572 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
6573 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
6574 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
6575 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
6576 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
6577 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
6578 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
6579 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
6580 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
6581 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
6582 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
6583 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
6584 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
6585 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
6586 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
6587 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
6588 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
6589 return BuiltinConstantArgRange(TheCall, 4, 0, 4);
6590 case RISCV::BI__builtin_riscv_ntl_load:
6591 case RISCV::BI__builtin_riscv_ntl_store:
6594 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
6595 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
6596 "Unexpected RISC-V nontemporal load/store builtin!");
6597 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
6598 unsigned NumArgs = IsStore ? 3 : 2;
6609 BuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
6614 DefaultFunctionArrayLvalueConversion(PointerArg);
6618 PointerArg = PointerArgResult.
get();
6622 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
6633 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
6645 Context, ValType,
false);
6646 ValArg = PerformCopyInitialization(Entity,
SourceLocation(), ValArg);
6658 bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
6660 if (BuiltinID == SystemZ::BI__builtin_tabort) {
6662 if (std::optional<llvm::APSInt> AbortCode =
6664 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
6665 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
6671 unsigned i = 0, l = 0, u = 0;
6672 switch (BuiltinID) {
6673 default:
return false;
6674 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
6675 case SystemZ::BI__builtin_s390_verimb:
6676 case SystemZ::BI__builtin_s390_verimh:
6677 case SystemZ::BI__builtin_s390_verimf:
6678 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
6679 case SystemZ::BI__builtin_s390_vfaeb:
6680 case SystemZ::BI__builtin_s390_vfaeh:
6681 case SystemZ::BI__builtin_s390_vfaef:
6682 case SystemZ::BI__builtin_s390_vfaebs:
6683 case SystemZ::BI__builtin_s390_vfaehs:
6684 case SystemZ::BI__builtin_s390_vfaefs:
6685 case SystemZ::BI__builtin_s390_vfaezb:
6686 case SystemZ::BI__builtin_s390_vfaezh:
6687 case SystemZ::BI__builtin_s390_vfaezf:
6688 case SystemZ::BI__builtin_s390_vfaezbs:
6689 case SystemZ::BI__builtin_s390_vfaezhs:
6690 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
6691 case SystemZ::BI__builtin_s390_vfisb:
6692 case SystemZ::BI__builtin_s390_vfidb:
6693 return BuiltinConstantArgRange(TheCall, 1, 0, 15) ||
6694 BuiltinConstantArgRange(TheCall, 2, 0, 15);
6695 case SystemZ::BI__builtin_s390_vftcisb:
6696 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
6697 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
6698 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
6699 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
6700 case SystemZ::BI__builtin_s390_vstrcb:
6701 case SystemZ::BI__builtin_s390_vstrch:
6702 case SystemZ::BI__builtin_s390_vstrcf:
6703 case SystemZ::BI__builtin_s390_vstrczb:
6704 case SystemZ::BI__builtin_s390_vstrczh:
6705 case SystemZ::BI__builtin_s390_vstrczf:
6706 case SystemZ::BI__builtin_s390_vstrcbs:
6707 case SystemZ::BI__builtin_s390_vstrchs:
6708 case SystemZ::BI__builtin_s390_vstrcfs:
6709 case SystemZ::BI__builtin_s390_vstrczbs:
6710 case SystemZ::BI__builtin_s390_vstrczhs:
6711 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
6712 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
6713 case SystemZ::BI__builtin_s390_vfminsb:
6714 case SystemZ::BI__builtin_s390_vfmaxsb:
6715 case SystemZ::BI__builtin_s390_vfmindb:
6716 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
6717 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
6718 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
6719 case SystemZ::BI__builtin_s390_vclfnhs:
6720 case SystemZ::BI__builtin_s390_vclfnls:
6721 case SystemZ::BI__builtin_s390_vcfn:
6722 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
6723 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
6725 return BuiltinConstantArgRange(TheCall, i, l, u);
6728 bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
6731 switch (BuiltinID) {
6732 case WebAssembly::BI__builtin_wasm_ref_null_extern:
6733 return BuiltinWasmRefNullExtern(TheCall);
6734 case WebAssembly::BI__builtin_wasm_ref_null_func:
6735 return BuiltinWasmRefNullFunc(TheCall);
6736 case WebAssembly::BI__builtin_wasm_table_get:
6737 return BuiltinWasmTableGet(TheCall);
6738 case WebAssembly::BI__builtin_wasm_table_set:
6739 return BuiltinWasmTableSet(TheCall);
6740 case WebAssembly::BI__builtin_wasm_table_size:
6741 return BuiltinWasmTableSize(TheCall);
6742 case WebAssembly::BI__builtin_wasm_table_grow:
6743 return BuiltinWasmTableGrow(TheCall);
6744 case WebAssembly::BI__builtin_wasm_table_fill:
6745 return BuiltinWasmTableFill(TheCall);
6746 case WebAssembly::BI__builtin_wasm_table_copy:
6747 return BuiltinWasmTableCopy(TheCall);
6754 const llvm::StringMap<bool> &FeatureMap) {
6758 unsigned MinElts = Info.
EC.getKnownMinValue();
6761 !FeatureMap.lookup(
"zve64d"))
6762 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
6767 !FeatureMap.lookup(
"zve64x"))
6768 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
6770 !FeatureMap.lookup(
"zvfhmin"))
6771 Diag(Loc, diag::err_riscv_type_requires_extension, D)
6772 << Ty <<
"zvfh or zvfhmin";
6774 !FeatureMap.lookup(
"experimental-zvfbfmin"))
6775 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfbfmin";
6777 !FeatureMap.lookup(
"zve32f"))
6778 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
6781 else if (!FeatureMap.lookup(
"zve32x"))
6782 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
6785 bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
6788 switch (BuiltinID) {
6789 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
6790 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
6791 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
6792 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
6800 bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
6804 unsigned ArgNum = 0;
6805 switch (BuiltinID) {
6808 case X86::BI__builtin_ia32_vcvttsd2si32:
6809 case X86::BI__builtin_ia32_vcvttsd2si64:
6810 case X86::BI__builtin_ia32_vcvttsd2usi32:
6811 case X86::BI__builtin_ia32_vcvttsd2usi64:
6812 case X86::BI__builtin_ia32_vcvttss2si32:
6813 case X86::BI__builtin_ia32_vcvttss2si64:
6814 case X86::BI__builtin_ia32_vcvttss2usi32:
6815 case X86::BI__builtin_ia32_vcvttss2usi64:
6816 case X86::BI__builtin_ia32_vcvttsh2si32:
6817 case X86::BI__builtin_ia32_vcvttsh2si64:
6818 case X86::BI__builtin_ia32_vcvttsh2usi32:
6819 case X86::BI__builtin_ia32_vcvttsh2usi64:
6822 case X86::BI__builtin_ia32_maxpd512:
6823 case X86::BI__builtin_ia32_maxps512:
6824 case X86::BI__builtin_ia32_minpd512:
6825 case X86::BI__builtin_ia32_minps512:
6826 case X86::BI__builtin_ia32_maxph512:
6827 case X86::BI__builtin_ia32_minph512:
6830 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
6831 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
6832 case X86::BI__builtin_ia32_cvtps2pd512_mask:
6833 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
6834 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
6835 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
6836 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
6837 case X86::BI__builtin_ia32_cvttps2dq512_mask:
6838 case X86::BI__builtin_ia32_cvttps2qq512_mask:
6839 case X86::BI__builtin_ia32_cvttps2udq512_mask:
6840 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
6841 case X86::BI__builtin_ia32_vcvttph2w512_mask:
6842 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
6843 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
6844 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
6845 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
6846 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
6847 case X86::BI__builtin_ia32_exp2pd_mask:
6848 case X86::BI__builtin_ia32_exp2ps_mask:
6849 case X86::BI__builtin_ia32_getexppd512_mask:
6850 case X86::BI__builtin_ia32_getexpps512_mask:
6851 case X86::BI__builtin_ia32_getexpph512_mask:
6852 case X86::BI__builtin_ia32_rcp28pd_mask:
6853 case X86::BI__builtin_ia32_rcp28ps_mask:
6854 case X86::BI__builtin_ia32_rsqrt28pd_mask:
6855 case X86::BI__builtin_ia32_rsqrt28ps_mask:
6856 case X86::BI__builtin_ia32_vcomisd:
6857 case X86::BI__builtin_ia32_vcomiss:
6858 case X86::BI__builtin_ia32_vcomish:
6859 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
6862 case X86::BI__builtin_ia32_cmppd512_mask:
6863 case X86::BI__builtin_ia32_cmpps512_mask:
6864 case X86::BI__builtin_ia32_cmpsd_mask:
6865 case X86::BI__builtin_ia32_cmpss_mask:
6866 case X86::BI__builtin_ia32_cmpsh_mask:
6867 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
6868 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
6869 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
6870 case X86::BI__builtin_ia32_getexpsd128_round_mask:
6871 case X86::BI__builtin_ia32_getexpss128_round_mask:
6872 case X86::BI__builtin_ia32_getexpsh128_round_mask:
6873 case X86::BI__builtin_ia32_getmantpd512_mask:
6874 case X86::BI__builtin_ia32_getmantps512_mask:
6875 case X86::BI__builtin_ia32_getmantph512_mask:
6876 case X86::BI__builtin_ia32_maxsd_round_mask:
6877 case X86::BI__builtin_ia32_maxss_round_mask:
6878 case X86::BI__builtin_ia32_maxsh_round_mask:
6879 case X86::BI__builtin_ia32_minsd_round_mask:
6880 case X86::BI__builtin_ia32_minss_round_mask:
6881 case X86::BI__builtin_ia32_minsh_round_mask:
6882 case X86::BI__builtin_ia32_rcp28sd_round_mask:
6883 case X86::BI__builtin_ia32_rcp28ss_round_mask:
6884 case X86::BI__builtin_ia32_reducepd512_mask:
6885 case X86::BI__builtin_ia32_reduceps512_mask:
6886 case X86::BI__builtin_ia32_reduceph512_mask:
6887 case X86::BI__builtin_ia32_rndscalepd_mask:
6888 case X86::BI__builtin_ia32_rndscaleps_mask:
6889 case X86::BI__builtin_ia32_rndscaleph_mask:
6890 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
6891 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
6894 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6895 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6896 case X86::BI__builtin_ia32_fixupimmps512_mask:
6897 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6898 case X86::BI__builtin_ia32_fixupimmsd_mask:
6899 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6900 case X86::BI__builtin_ia32_fixupimmss_mask:
6901 case X86::BI__builtin_ia32_fixupimmss_maskz:
6902 case X86::BI__builtin_ia32_getmantsd_round_mask:
6903 case X86::BI__builtin_ia32_getmantss_round_mask:
6904 case X86::BI__builtin_ia32_getmantsh_round_mask:
6905 case X86::BI__builtin_ia32_rangepd512_mask:
6906 case X86::BI__builtin_ia32_rangeps512_mask:
6907 case X86::BI__builtin_ia32_rangesd128_round_mask:
6908 case X86::BI__builtin_ia32_rangess128_round_mask:
6909 case X86::BI__builtin_ia32_reducesd_mask:
6910 case X86::BI__builtin_ia32_reducess_mask:
6911 case X86::BI__builtin_ia32_reducesh_mask:
6912 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6913 case X86::BI__builtin_ia32_rndscaless_round_mask:
6914 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6917 case X86::BI__builtin_ia32_vcvtsd2si64:
6918 case X86::BI__builtin_ia32_vcvtsd2si32:
6919 case X86::BI__builtin_ia32_vcvtsd2usi32:
6920 case X86::BI__builtin_ia32_vcvtsd2usi64:
6921 case X86::BI__builtin_ia32_vcvtss2si32:
6922 case X86::BI__builtin_ia32_vcvtss2si64:
6923 case X86::BI__builtin_ia32_vcvtss2usi32:
6924 case X86::BI__builtin_ia32_vcvtss2usi64:
6925 case X86::BI__builtin_ia32_vcvtsh2si32:
6926 case X86::BI__builtin_ia32_vcvtsh2si64:
6927 case X86::BI__builtin_ia32_vcvtsh2usi32:
6928 case X86::BI__builtin_ia32_vcvtsh2usi64:
6929 case X86::BI__builtin_ia32_sqrtpd512:
6930 case X86::BI__builtin_ia32_sqrtps512:
6931 case X86::BI__builtin_ia32_sqrtph512:
6935 case X86::BI__builtin_ia32_addph512:
6936 case X86::BI__builtin_ia32_divph512:
6937 case X86::BI__builtin_ia32_mulph512:
6938 case X86::BI__builtin_ia32_subph512:
6939 case X86::BI__builtin_ia32_addpd512:
6940 case X86::BI__builtin_ia32_addps512:
6941 case X86::BI__builtin_ia32_divpd512:
6942 case X86::BI__builtin_ia32_divps512:
6943 case X86::BI__builtin_ia32_mulpd512:
6944 case X86::BI__builtin_ia32_mulps512:
6945 case X86::BI__builtin_ia32_subpd512:
6946 case X86::BI__builtin_ia32_subps512:
6947 case X86::BI__builtin_ia32_cvtsi2sd64:
6948 case X86::BI__builtin_ia32_cvtsi2ss32:
6949 case X86::BI__builtin_ia32_cvtsi2ss64:
6950 case X86::BI__builtin_ia32_cvtusi2sd64:
6951 case X86::BI__builtin_ia32_cvtusi2ss32:
6952 case X86::BI__builtin_ia32_cvtusi2ss64:
6953 case X86::BI__builtin_ia32_vcvtusi2sh:
6954 case X86::BI__builtin_ia32_vcvtusi642sh:
6955 case X86::BI__builtin_ia32_vcvtsi2sh:
6956 case X86::BI__builtin_ia32_vcvtsi642sh:
6960 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
6961 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
6962 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
6963 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
6964 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
6965 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
6966 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
6967 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
6968 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
6969 case X86::BI__builtin_ia32_cvtps2dq512_mask:
6970 case X86::BI__builtin_ia32_cvtps2qq512_mask:
6971 case X86::BI__builtin_ia32_cvtps2udq512_mask:
6972 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
6973 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
6974 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
6975 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
6976 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
6977 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
6978 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
6979 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
6980 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
6981 case X86::BI__builtin_ia32_vcvtph2w512_mask:
6982 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
6983 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
6984 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
6985 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
6986 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
6987 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
6988 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
6992 case X86::BI__builtin_ia32_addsh_round_mask:
6993 case X86::BI__builtin_ia32_addss_round_mask:
6994 case X86::BI__builtin_ia32_addsd_round_mask:
6995 case X86::BI__builtin_ia32_divsh_round_mask:
6996 case X86::BI__builtin_ia32_divss_round_mask:
6997 case X86::BI__builtin_ia32_divsd_round_mask:
6998 case X86::BI__builtin_ia32_mulsh_round_mask:
6999 case X86::BI__builtin_ia32_mulss_round_mask:
7000 case X86::BI__builtin_ia32_mulsd_round_mask:
7001 case X86::BI__builtin_ia32_subsh_round_mask:
7002 case X86::BI__builtin_ia32_subss_round_mask:
7003 case X86::BI__builtin_ia32_subsd_round_mask:
7004 case X86::BI__builtin_ia32_scalefph512_mask:
7005 case X86::BI__builtin_ia32_scalefpd512_mask:
7006 case X86::BI__builtin_ia32_scalefps512_mask:
7007 case X86::BI__builtin_ia32_scalefsd_round_mask:
7008 case X86::BI__builtin_ia32_scalefss_round_mask:
7009 case X86::BI__builtin_ia32_scalefsh_round_mask:
7010 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
7011 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
7012 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
7013 case X86::BI__builtin_ia32_sqrtsd_round_mask:
7014 case X86::BI__builtin_ia32_sqrtss_round_mask:
7015 case X86::BI__builtin_ia32_sqrtsh_round_mask:
7016 case X86::BI__builtin_ia32_vfmaddsd3_mask:
7017 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
7018 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
7019 case X86::BI__builtin_ia32_vfmaddss3_mask:
7020 case X86::BI__builtin_ia32_vfmaddss3_maskz:
7021 case X86::BI__builtin_ia32_vfmaddss3_mask3:
7022 case X86::BI__builtin_ia32_vfmaddsh3_mask:
7023 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
7024 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
7025 case X86::BI__builtin_ia32_vfmaddpd512_mask:
7026 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
7027 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
7028 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
7029 case X86::BI__builtin_ia32_vfmaddps512_mask:
7030 case X86::BI__builtin_ia32_vfmaddps512_maskz:
7031 case X86::BI__builtin_ia32_vfmaddps512_mask3:
7032 case X86::BI__builtin_ia32_vfmsubps512_mask3:
7033 case X86::BI__builtin_ia32_vfmaddph512_mask:
7034 case X86::BI__builtin_ia32_vfmaddph512_maskz:
7035 case X86::BI__builtin_ia32_vfmaddph512_mask3:
7036 case X86::BI__builtin_ia32_vfmsubph512_mask3:
7037 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
7038 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
7039 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
7040 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
7041 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
7042 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
7043 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
7044 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
7045 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
7046 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
7047 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
7048 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
7049 case X86::BI__builtin_ia32_vfmaddcsh_mask:
7050 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
7051 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
7052 case X86::BI__builtin_ia32_vfmaddcph512_mask:
7053 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
7054 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
7055 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
7056 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
7057 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
7058 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
7059 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
7060 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
7061 case X86::BI__builtin_ia32_vfmulcsh_mask:
7062 case X86::BI__builtin_ia32_vfmulcph512_mask:
7063 case X86::BI__builtin_ia32_vfcmulcsh_mask:
7064 case X86::BI__builtin_ia32_vfcmulcph512_mask:
7078 if (BuiltinConstantArg(TheCall, ArgNum, Result))
7087 (!HasRC && Result == 12) ||
7088 (HasRC && Result.getZExtValue() >= 8 && Result.getZExtValue() <= 11))
7091 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
7096 bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
7098 unsigned ArgNum = 0;
7099 switch (BuiltinID) {
7102 case X86::BI__builtin_ia32_gatherpfdpd:
7103 case X86::BI__builtin_ia32_gatherpfdps:
7104 case X86::BI__builtin_ia32_gatherpfqpd:
7105 case X86::BI__builtin_ia32_gatherpfqps:
7106 case X86::BI__builtin_ia32_scatterpfdpd:
7107 case X86::BI__builtin_ia32_scatterpfdps:
7108 case X86::BI__builtin_ia32_scatterpfqpd:
7109 case X86::BI__builtin_ia32_scatterpfqps:
7112 case X86::BI__builtin_ia32_gatherd_pd:
7113 case X86::BI__builtin_ia32_gatherd_pd256:
7114 case X86::BI__builtin_ia32_gatherq_pd:
7115 case X86::BI__builtin_ia32_gatherq_pd256:
7116 case X86::BI__builtin_ia32_gatherd_ps:
7117 case X86::BI__builtin_ia32_gatherd_ps256:
7118 case X86::BI__builtin_ia32_gatherq_ps:
7119 case X86::BI__builtin_ia32_gatherq_ps256:
7120 case X86::BI__builtin_ia32_gatherd_q:
7121 case X86::BI__builtin_ia32_gatherd_q256:
7122 case X86::BI__builtin_ia32_gatherq_q:
7123 case X86::BI__builtin_ia32_gatherq_q256:
7124 case X86::BI__builtin_ia32_gatherd_d:
7125 case X86::BI__builtin_ia32_gatherd_d256:
7126 case X86::BI__builtin_ia32_gatherq_d:
7127 case X86::BI__builtin_ia32_gatherq_d256:
7128 case X86::BI__builtin_ia32_gather3div2df:
7129 case X86::BI__builtin_ia32_gather3div2di:
7130 case X86::BI__builtin_ia32_gather3div4df:
7131 case X86::BI__builtin_ia32_gather3div4di:
7132 case X86::BI__builtin_ia32_gather3div4sf:
7133 case X86::BI__builtin_ia32_gather3div4si:
7134 case X86::BI__builtin_ia32_gather3div8sf:
7135 case X86::BI__builtin_ia32_gather3div8si:
7136 case X86::BI__builtin_ia32_gather3siv2df:
7137 case X86::BI__builtin_ia32_gather3siv2di:
7138 case X86::BI__builtin_ia32_gather3siv4df:
7139 case X86::BI__builtin_ia32_gather3siv4di:
7140 case X86::BI__builtin_ia32_gather3siv4sf:
7141 case X86::BI__builtin_ia32_gather3siv4si:
7142 case X86::BI__builtin_ia32_gather3siv8sf:
7143 case X86::BI__builtin_ia32_gather3siv8si:
7144 case X86::BI__builtin_ia32_gathersiv8df:
7145 case X86::BI__builtin_ia32_gathersiv16sf:
7146 case X86::BI__builtin_ia32_gatherdiv8df:
7147 case X86::BI__builtin_ia32_gatherdiv16sf:
7148 case X86::BI__builtin_ia32_gathersiv8di:
7149 case X86::BI__builtin_ia32_gathersiv16si:
7150 case X86::BI__builtin_ia32_gatherdiv8di:
7151 case X86::BI__builtin_ia32_gatherdiv16si:
7152 case X86::BI__builtin_ia32_scatterdiv2df:
7153 case X86::BI__builtin_ia32_scatterdiv2di:
7154 case X86::BI__builtin_ia32_scatterdiv4df:
7155 case X86::BI__builtin_ia32_scatterdiv4di:
7156 case X86::BI__builtin_ia32_scatterdiv4sf:
7157 case X86::BI__builtin_ia32_scatterdiv4si:
7158 case X86::BI__builtin_ia32_scatterdiv8sf:
7159 case X86::BI__builtin_ia32_scatterdiv8si:
7160 case X86::BI__builtin_ia32_scattersiv2df:
7161 case X86::BI__builtin_ia32_scattersiv2di:
7162 case X86::BI__builtin_ia32_scattersiv4df:
7163 case X86::BI__builtin_ia32_scattersiv4di:
7164 case X86::BI__builtin_ia32_scattersiv4sf:
7165 case X86::BI__builtin_ia32_scattersiv4si:
7166 case X86::BI__builtin_ia32_scattersiv8sf:
7167 case X86::BI__builtin_ia32_scattersiv8si:
7168 case X86::BI__builtin_ia32_scattersiv8df:
7169 case X86::BI__builtin_ia32_scattersiv16sf:
7170 case X86::BI__builtin_ia32_scatterdiv8df:
7171 case X86::BI__builtin_ia32_scatterdiv16sf:
7172 case X86::BI__builtin_ia32_scattersiv8di:
7173 case X86::BI__builtin_ia32_scattersiv16si:
7174 case X86::BI__builtin_ia32_scatterdiv8di:
7175 case X86::BI__builtin_ia32_scatterdiv16si:
7188 if (BuiltinConstantArg(TheCall, ArgNum, Result))
7191 if (Result == 1 || Result == 2 || Result == 4 || Result == 8)
7194 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
7200 bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
7202 for (
int ArgNum : ArgNums) {
7209 bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
7213 std::bitset<TileRegHigh + 1> ArgValues;
7214 for (
int ArgNum : ArgNums) {
7220 if (BuiltinConstantArg(TheCall, ArgNum, Result))
7222 int ArgExtValue = Result.getExtValue();
7224 "Incorrect tile register num.");
7225 if (ArgValues.test(ArgExtValue))
7227 diag::err_x86_builtin_tile_arg_duplicate)
7229 ArgValues.set(ArgExtValue);
7234 bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
7236 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
7237 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
7240 bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
7241 switch (BuiltinID) {
7244 case X86::BI__builtin_ia32_tileloadd64:
7245 case X86::BI__builtin_ia32_tileloaddt164:
7246 case X86::BI__builtin_ia32_tilestored64:
7247 case X86::BI__builtin_ia32_tilezero:
7248 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
7249 case X86::BI__builtin_ia32_tdpbssd:
7250 case X86::BI__builtin_ia32_tdpbsud:
7251 case X86::BI__builtin_ia32_tdpbusd:
7252 case X86::BI__builtin_ia32_tdpbuud:
7253 case X86::BI__builtin_ia32_tdpbf16ps:
7254 case X86::BI__builtin_ia32_tdpfp16ps:
7255 case X86::BI__builtin_ia32_tcmmimfp16ps:
7256 case X86::BI__builtin_ia32_tcmmrlfp16ps:
7257 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
7262 switch (BuiltinID) {
7263 case X86::BI__builtin_ia32_readeflags_u32:
7264 case X86::BI__builtin_ia32_writeeflags_u32:
7271 bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
7274 const llvm::Triple &TT = TI.
getTriple();
7277 diag::err_32_bit_builtin_64_bit_tgt);
7280 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
7284 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
7288 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
7293 int i = 0, l = 0, u = 0;
7294 switch (BuiltinID) {
7297 case X86::BI__builtin_ia32_vec_ext_v2si:
7298 case X86::BI__builtin_ia32_vec_ext_v2di:
7299 case X86::BI__builtin_ia32_vextractf128_pd256:
7300 case X86::BI__builtin_ia32_vextractf128_ps256:
7301 case X86::BI__builtin_ia32_vextractf128_si256:
7302 case X86::BI__builtin_ia32_extract128i256:
7303 case X86::BI__builtin_ia32_extractf64x4_mask:
7304 case X86::BI__builtin_ia32_extracti64x4_mask:
7305 case X86::BI__builtin_ia32_extractf32x8_mask:
7306 case X86::BI__builtin_ia32_extracti32x8_mask:
7307 case X86::BI__builtin_ia32_extractf64x2_256_mask:
7308 case X86::BI__builtin_ia32_extracti64x2_256_mask:
7309 case X86::BI__builtin_ia32_extractf32x4_256_mask:
7310 case X86::BI__builtin_ia32_extracti32x4_256_mask:
7311 i = 1; l = 0; u = 1;
7313 case X86::BI__builtin_ia32_vec_set_v2di:
7314 case X86::BI__builtin_ia32_vinsertf128_pd256:
7315 case X86::BI__builtin_ia32_vinsertf128_ps256:
7316 case X86::BI__builtin_ia32_vinsertf128_si256:
7317 case X86::BI__builtin_ia32_insert128i256:
7318 case X86::BI__builtin_ia32_insertf32x8:
7319 case X86::BI__builtin_ia32_inserti32x8:
7320 case X86::BI__builtin_ia32_insertf64x4:
7321 case X86::BI__builtin_ia32_inserti64x4:
7322 case X86::BI__builtin_ia32_insertf64x2_256:
7323 case X86::BI__builtin_ia32_inserti64x2_256:
7324 case X86::BI__builtin_ia32_insertf32x4_256:
7325 case X86::BI__builtin_ia32_inserti32x4_256:
7326 i = 2; l = 0; u = 1;
7328 case X86::BI__builtin_ia32_vpermilpd:
7329 case X86::BI__builtin_ia32_vec_ext_v4hi:
7330 case X86::BI__builtin_ia32_vec_ext_v4si:
7331 case X86::BI__builtin_ia32_vec_ext_v4sf:
7332 case X86::BI__builtin_ia32_vec_ext_v4di:
7333 case X86::BI__builtin_ia32_extractf32x4_mask:
7334 case X86::BI__builtin_ia32_extracti32x4_mask:
7335 case X86::BI__builtin_ia32_extractf64x2_512_mask:
7336 case X86::BI__builtin_ia32_extracti64x2_512_mask:
7337 i = 1; l = 0; u = 3;
7339 case X86::BI_mm_prefetch:
7340 case X86::BI__builtin_ia32_vec_ext_v8hi:
7341 case X86::BI__builtin_ia32_vec_ext_v8si:
7342 i = 1; l = 0; u = 7;
7344 case X86::BI__builtin_ia32_sha1rnds4:
7345 case X86::BI__builtin_ia32_blendpd:
7346 case X86::BI__builtin_ia32_shufpd:
7347 case X86::BI__builtin_ia32_vec_set_v4hi:
7348 case X86::BI__builtin_ia32_vec_set_v4si:
7349 case X86::BI__builtin_ia32_vec_set_v4di:
7350 case X86::BI__builtin_ia32_shuf_f32x4_256:
7351 case X86::BI__builtin_ia32_shuf_f64x2_256:
7352 case X86::BI__builtin_ia32_shuf_i32x4_256:
7353 case X86::BI__builtin_ia32_shuf_i64x2_256:
7354 case X86::BI__builtin_ia32_insertf64x2_512:
7355 case X86::BI__builtin_ia32_inserti64x2_512:
7356 case X86::BI__builtin_ia32_insertf32x4:
7357 case X86::BI__builtin_ia32_inserti32x4:
7358 i = 2; l = 0; u = 3;
7360 case X86::BI__builtin_ia32_vpermil2pd:
7361 case X86::BI__builtin_ia32_vpermil2pd256:
7362 case X86::BI__builtin_ia32_vpermil2ps:
7363 case X86::BI__builtin_ia32_vpermil2ps256:
7364 i = 3; l = 0; u = 3;
7366 case X86::BI__builtin_ia32_cmpb128_mask:
7367 case X86::BI__builtin_ia32_cmpw128_mask:
7368 case X86::BI__builtin_ia32_cmpd128_mask:
7369 case X86::BI__builtin_ia32_cmpq128_mask:
7370 case X86::BI__builtin_ia32_cmpb256_mask:
7371 case X86::BI__builtin_ia32_cmpw256_mask:
7372 case X86::BI__builtin_ia32_cmpd256_mask:
7373 case X86::BI__builtin_ia32_cmpq256_mask:
7374 case X86::BI__builtin_ia32_cmpb512_mask:
7375 case X86::BI__builtin_ia32_cmpw512_mask:
7376 case X86::BI__builtin_ia32_cmpd512_mask:
7377 case X86::BI__builtin_ia32_cmpq512_mask:
7378 case X86::BI__builtin_ia32_ucmpb128_mask:
7379 case X86::BI__builtin_ia32_ucmpw128_mask:
7380 case X86::BI__builtin_ia32_ucmpd128_mask:
7381 case X86::BI__builtin_ia32_ucmpq128_mask:
7382 case X86::BI__builtin_ia32_ucmpb256_mask:
7383 case X86::BI__builtin_ia32_ucmpw256_mask:
7384 case X86::BI__builtin_ia32_ucmpd256_mask:
7385 case X86::BI__builtin_ia32_ucmpq256_mask:
7386 case X86::BI__builtin_ia32_ucmpb512_mask:
7387 case X86::BI__builtin_ia32_ucmpw512_mask:
7388 case X86::BI__builtin_ia32_ucmpd512_mask:
7389 case X86::BI__builtin_ia32_ucmpq512_mask:
7390 case X86::BI__builtin_ia32_vpcomub:
7391 case X86::BI__builtin_ia32_vpcomuw:
7392 case X86::BI__builtin_ia32_vpcomud:
7393 case X86::BI__builtin_ia32_vpcomuq:
7394 case X86::BI__builtin_ia32_vpcomb:
7395 case X86::BI__builtin_ia32_vpcomw:
7396 case X86::BI__builtin_ia32_vpcomd:
7397 case X86::BI__builtin_ia32_vpcomq:
7398 case X86::BI__builtin_ia32_vec_set_v8hi:
7399 case X86::BI__builtin_ia32_vec_set_v8si:
7400 i = 2; l = 0; u = 7;
7402 case X86::BI__builtin_ia32_vpermilpd256:
7403 case X86::BI__builtin_ia32_roundps:
7404 case X86::BI__builtin_ia32_roundpd:
7405 case X86::BI__builtin_ia32_roundps256:
7406 case X86::BI__builtin_ia32_roundpd256:
7407 case X86::BI__builtin_ia32_getmantpd128_mask:
7408 case X86::BI__builtin_ia32_getmantpd256_mask:
7409 case X86::BI__builtin_ia32_getmantps128_mask:
7410 case X86::BI__builtin_ia32_getmantps256_mask:
7411 case X86::BI__builtin_ia32_getmantpd512_mask:
7412 case X86::BI__builtin_ia32_getmantps512_mask:
7413 case X86::BI__builtin_ia32_getmantph128_mask:
7414 case X86::BI__builtin_ia32_getmantph256_mask:
7415 case X86::BI__builtin_ia32_getmantph512_mask:
7416 case X86::BI__builtin_ia32_vec_ext_v16qi:
7417 case X86::BI__builtin_ia32_vec_ext_v16hi:
7418 i = 1; l = 0; u = 15;
7420 case X86::BI__builtin_ia32_pblendd128:
7421 case X86::BI__builtin_ia32_blendps:
7422 case X86::BI__builtin_ia32_blendpd256:
7423 case X86::BI__builtin_ia32_shufpd256:
7424 case X86::BI__builtin_ia32_roundss:
7425 case X86::BI__builtin_ia32_roundsd:
7426 case X86::BI__builtin_ia32_rangepd128_mask:
7427 case X86::BI__builtin_ia32_rangepd256_mask:
7428 case X86::BI__builtin_ia32_rangepd512_mask:
7429 case X86::BI__builtin_ia32_rangeps128_mask:
7430 case X86::BI__builtin_ia32_rangeps256_mask:
7431 case X86::BI__builtin_ia32_rangeps512_mask:
7432 case X86::BI__builtin_ia32_getmantsd_round_mask:
7433 case X86::BI__builtin_ia32_getmantss_round_mask:
7434 case X86::BI__builtin_ia32_getmantsh_round_mask:
7435 case X86::BI__builtin_ia32_vec_set_v16qi:
7436 case X86::BI__builtin_ia32_vec_set_v16hi:
7437 i = 2; l = 0; u = 15;
7439 case X86::BI__builtin_ia32_vec_ext_v32qi:
7440 i = 1; l = 0; u = 31;
7442 case X86::BI__builtin_ia32_cmpps:
7443 case X86::BI__builtin_ia32_cmpss:
7444 case X86::BI__builtin_ia32_cmppd:
7445 case X86::BI__builtin_ia32_cmpsd:
7446 case X86::BI__builtin_ia32_cmpps256:
7447 case X86::BI__builtin_ia32_cmppd256:
7448 case X86::BI__builtin_ia32_cmpps128_mask:
7449 case X86::BI__builtin_ia32_cmppd128_mask:
7450 case X86::BI__builtin_ia32_cmpps256_mask:
7451 case X86::BI__builtin_ia32_cmppd256_mask:
7452 case X86::BI__builtin_ia32_cmpps512_mask:
7453 case X86::BI__builtin_ia32_cmppd512_mask:
7454 case X86::BI__builtin_ia32_cmpsd_mask:
7455 case X86::BI__builtin_ia32_cmpss_mask:
7456 case X86::BI__builtin_ia32_vec_set_v32qi:
7457 i = 2; l = 0; u = 31;
7459 case X86::BI__builtin_ia32_permdf256:
7460 case X86::BI__builtin_ia32_permdi256:
7461 case X86::BI__builtin_ia32_permdf512:
7462 case X86::BI__builtin_ia32_permdi512:
7463 case X86::BI__builtin_ia32_vpermilps:
7464 case X86::BI__builtin_ia32_vpermilps256:
7465 case X86::BI__builtin_ia32_vpermilpd512:
7466 case X86::BI__builtin_ia32_vpermilps512:
7467 case X86::BI__builtin_ia32_pshufd:
7468 case X86::BI__builtin_ia32_pshufd256:
7469 case X86::BI__builtin_ia32_pshufd512:
7470 case X86::BI__builtin_ia32_pshufhw:
7471 case X86::BI__builtin_ia32_pshufhw256:
7472 case X86::BI__builtin_ia32_pshufhw512:
7473 case X86::BI__builtin_ia32_pshuflw:
7474 case X86::BI__builtin_ia32_pshuflw256:
7475 case X86::BI__builtin_ia32_pshuflw512:
7476 case X86::BI__builtin_ia32_vcvtps2ph:
7477 case X86::BI__builtin_ia32_vcvtps2ph_mask:
7478 case X86::BI__builtin_ia32_vcvtps2ph256:
7479 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
7480 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
7481 case X86::BI__builtin_ia32_rndscaleps_128_mask:
7482 case X86::BI__builtin_ia32_rndscalepd_128_mask:
7483 case X86::BI__builtin_ia32_rndscaleps_256_mask:
7484 case X86::BI__builtin_ia32_rndscalepd_256_mask:
7485 case X86::BI__builtin_ia32_rndscaleps_mask:
7486 case X86::BI__builtin_ia32_rndscalepd_mask:
7487 case X86::BI__builtin_ia32_rndscaleph_mask:
7488 case X86::BI__builtin_ia32_reducepd128_mask:
7489 case X86::BI__builtin_ia32_reducepd256_mask:
7490 case X86::BI__builtin_ia32_reducepd512_mask:
7491 case X86::BI__builtin_ia32_reduceps128_mask:
7492 case X86::BI__builtin_ia32_reduceps256_mask:
7493 case X86::BI__builtin_ia32_reduceps512_mask:
7494 case X86::BI__builtin_ia32_reduceph128_mask:
7495 case X86::BI__builtin_ia32_reduceph256_mask:
7496 case X86::BI__builtin_ia32_reduceph512_mask:
7497 case X86::BI__builtin_ia32_prold512:
7498 case X86::BI__builtin_ia32_prolq512:
7499 case X86::BI__builtin_ia32_prold128:
7500 case X86::BI__builtin_ia32_prold256:
7501 case X86::BI__builtin_ia32_prolq128:
7502 case X86::BI__builtin_ia32_prolq256:
7503 case X86::BI__builtin_ia32_prord512:
7504 case X86::BI__builtin_ia32_prorq512:
7505 case X86::BI__builtin_ia32_prord128:
7506 case X86::BI__builtin_ia32_prord256:
7507 case X86::BI__builtin_ia32_prorq128:
7508 case X86::BI__builtin_ia32_prorq256:
7509 case X86::BI__builtin_ia32_fpclasspd128_mask:
7510 case X86::BI__builtin_ia32_fpclasspd256_mask:
7511 case X86::BI__builtin_ia32_fpclassps128_mask:
7512 case X86::BI__builtin_ia32_fpclassps256_mask:
7513 case X86::BI__builtin_ia32_fpclassps512_mask:
7514 case X86::BI__builtin_ia32_fpclasspd512_mask:
7515 case X86::BI__builtin_ia32_fpclassph128_mask:
7516 case X86::BI__builtin_ia32_fpclassph256_mask:
7517 case X86::BI__builtin_ia32_fpclassph512_mask:
7518 case X86::BI__builtin_ia32_fpclasssd_mask:
7519 case X86::BI__builtin_ia32_fpclassss_mask:
7520 case X86::BI__builtin_ia32_fpclasssh_mask:
7521 case X86::BI__builtin_ia32_pslldqi128_byteshift:
7522 case X86::BI__builtin_ia32_pslldqi256_byteshift:
7523 case X86::BI__builtin_ia32_pslldqi512_byteshift:
7524 case X86::BI__builtin_ia32_psrldqi128_byteshift:
7525 case X86::BI__builtin_ia32_psrldqi256_byteshift:
7526 case X86::BI__builtin_ia32_psrldqi512_byteshift:
7527 case X86::BI__builtin_ia32_kshiftliqi:
7528 case X86::BI__builtin_ia32_kshiftlihi:
7529 case X86::BI__builtin_ia32_kshiftlisi:
7530 case X86::BI__builtin_ia32_kshiftlidi:
7531 case X86::BI__builtin_ia32_kshiftriqi:
7532 case X86::BI__builtin_ia32_kshiftrihi:
7533 case X86::BI__builtin_ia32_kshiftrisi:
7534 case X86::BI__builtin_ia32_kshiftridi:
7535 i = 1; l = 0; u = 255;
7537 case X86::BI__builtin_ia32_vperm2f128_pd256:
7538 case X86::BI__builtin_ia32_vperm2f128_ps256:
7539 case X86::BI__builtin_ia32_vperm2f128_si256:
7540 case X86::BI__builtin_ia32_permti256:
7541 case X86::BI__builtin_ia32_pblendw128:
7542 case X86::BI__builtin_ia32_pblendw256:
7543 case X86::BI__builtin_ia32_blendps256:
7544 case X86::BI__builtin_ia32_pblendd256:
7545 case X86::BI__builtin_ia32_palignr128:
7546 case X86::BI__builtin_ia32_palignr256:
7547 case X86::BI__builtin_ia32_palignr512:
7548 case X86::BI__builtin_ia32_alignq512:
7549 case X86::BI__builtin_ia32_alignd512:
7550 case X86::BI__builtin_ia32_alignd128:
7551 case X86::BI__builtin_ia32_alignd256:
7552 case X86::BI__builtin_ia32_alignq128:
7553 case X86::BI__builtin_ia32_alignq256:
7554 case X86::BI__builtin_ia32_vcomisd:
7555 case X86::BI__builtin_ia32_vcomiss:
7556 case X86::BI__builtin_ia32_shuf_f32x4:
7557 case X86::BI__builtin_ia32_shuf_f64x2:
7558 case X86::BI__builtin_ia32_shuf_i32x4:
7559 case X86::BI__builtin_ia32_shuf_i64x2:
7560 case X86::BI__builtin_ia32_shufpd512:
7561 case X86::BI__builtin_ia32_shufps:
7562 case X86::BI__builtin_ia32_shufps256:
7563 case X86::BI__builtin_ia32_shufps512:
7564 case X86::BI__builtin_ia32_dbpsadbw128:
7565 case X86::BI__builtin_ia32_dbpsadbw256:
7566 case X86::BI__builtin_ia32_dbpsadbw512:
7567 case X86::BI__builtin_ia32_vpshldd128:
7568 case X86::BI__builtin_ia32_vpshldd256:
7569 case X86::BI__builtin_ia32_vpshldd512:
7570 case X86::BI__builtin_ia32_vpshldq128:
7571 case X86::BI__builtin_ia32_vpshldq256:
7572 case X86::BI__builtin_ia32_vpshldq512:
7573 case X86::BI__builtin_ia32_vpshldw128:
7574 case X86::BI__builtin_ia32_vpshldw256:
7575 case X86::BI__builtin_ia32_vpshldw512:
7576 case X86::BI__builtin_ia32_vpshrdd128:
7577 case X86::BI__builtin_ia32_vpshrdd256:
7578 case X86::BI__builtin_ia32_vpshrdd512:
7579 case X86::BI__builtin_ia32_vpshrdq128:
7580 case X86::BI__builtin_ia32_vpshrdq256:
7581 case X86::BI__builtin_ia32_vpshrdq512:
7582 case X86::BI__builtin_ia32_vpshrdw128:
7583 case X86::BI__builtin_ia32_vpshrdw256:
7584 case X86::BI__builtin_ia32_vpshrdw512:
7585 i = 2; l = 0; u = 255;
7587 case X86::BI__builtin_ia32_fixupimmpd512_mask:
7588 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
7589 case X86::BI__builtin_ia32_fixupimmps512_mask:
7590 case X86::BI__builtin_ia32_fixupimmps512_maskz:
7591 case X86::BI__builtin_ia32_fixupimmsd_mask:
7592 case X86::BI__builtin_ia32_fixupimmsd_maskz:
7593 case X86::BI__builtin_ia32_fixupimmss_mask:
7594 case X86::BI__builtin_ia32_fixupimmss_maskz:
7595 case X86::BI__builtin_ia32_fixupimmpd128_mask:
7596 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
7597 case X86::BI__builtin_ia32_fixupimmpd256_mask:
7598 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
7599 case X86::BI__builtin_ia32_fixupimmps128_mask:
7600 case X86::BI__builtin_ia32_fixupimmps128_maskz:
7601 case X86::BI__builtin_ia32_fixupimmps256_mask:
7602 case X86::BI__builtin_ia32_fixupimmps256_maskz:
7603 case X86::BI__builtin_ia32_pternlogd512_mask:
7604 case X86::BI__builtin_ia32_pternlogd512_maskz:
7605 case X86::BI__builtin_ia32_pternlogq512_mask:
7606 case X86::BI__builtin_ia32_pternlogq512_maskz:
7607 case X86::BI__builtin_ia32_pternlogd128_mask:
7608 case X86::BI__builtin_ia32_pternlogd128_maskz:
7609 case X86::BI__builtin_ia32_pternlogd256_mask:
7610 case X86::BI__builtin_ia32_pternlogd256_maskz:
7611 case X86::BI__builtin_ia32_pternlogq128_mask:
7612 case X86::BI__builtin_ia32_pternlogq128_maskz:
7613 case X86::BI__builtin_ia32_pternlogq256_mask:
7614 case X86::BI__builtin_ia32_pternlogq256_maskz:
7615 case X86::BI__builtin_ia32_vsm3rnds2:
7616 i = 3; l = 0; u = 255;
7618 case X86::BI__builtin_ia32_gatherpfdpd:
7619 case X86::BI__builtin_ia32_gatherpfdps:
7620 case X86::BI__builtin_ia32_gatherpfqpd:
7621 case X86::BI__builtin_ia32_gatherpfqps:
7622 case X86::BI__builtin_ia32_scatterpfdpd:
7623 case X86::BI__builtin_ia32_scatterpfdps:
7624 case X86::BI__builtin_ia32_scatterpfqpd:
7625 case X86::BI__builtin_ia32_scatterpfqps:
7626 i = 4; l = 2; u = 3;
7628 case X86::BI__builtin_ia32_reducesd_mask:
7629 case X86::BI__builtin_ia32_reducess_mask:
7630 case X86::BI__builtin_ia32_rndscalesd_round_mask:
7631 case X86::BI__builtin_ia32_rndscaless_round_mask:
7632 case X86::BI__builtin_ia32_rndscalesh_round_mask:
7633 case X86::BI__builtin_ia32_reducesh_mask:
7634 i = 4; l = 0; u = 255;
7636 case X86::BI__builtin_ia32_cmpccxadd32:
7637 case X86::BI__builtin_ia32_cmpccxadd64:
7638 i = 3; l = 0; u = 15;
7646 return BuiltinConstantArgRange(TheCall, i, l, u,
false);
7656 for (
auto *FD :
Record->fields()) {
7660 T = AT->getElementType();
7680 bool Sema::CheckIntelFPGARegBuiltinFunctionCall(
unsigned BuiltinID,
7682 switch (BuiltinID) {
7683 case Builtin::BI__builtin_intel_fpga_reg: {
7696 Diag(Loc, diag::illegal_type_declared_here);
7709 bool Sema::CheckIntelFPGAMemBuiltinFunctionCall(
CallExpr *TheCall) {
7710 const unsigned MinNumArgs = 3;
7711 const unsigned MaxNumArgs = 7;
7726 if (!isa<PointerType>(PointerArgType))
7728 diag::err_intel_fpga_mem_arg_mismatch)
7737 << (PointeeType->
isRecordType() ? 1 : 0) << PointerArgType
7740 Diag(Loc, diag::illegal_type_declared_here);
7746 if (BuiltinConstantArg(TheCall, 1, Result))
7750 if (BuiltinConstantArg(TheCall, 2, Result))
7754 diag::err_intel_fpga_mem_arg_mismatch) << 1;
7757 for (
unsigned I = MinNumArgs; I != NumArgs; ++I) {
7758 if (BuiltinConstantArg(TheCall, I, Result))
7764 TheCall->
setType(PointerArgType);
7768 bool Sema::CheckIntelSYCLPtrAnnotationBuiltinFunctionCall(
unsigned BuiltinID,
7777 if (!(NumArgs & 0x1)) {
7779 diag::err_intel_sycl_ptr_annotation_arg_number_mismatch);
7786 if (!isa<PointerType>(PointerArgType))
7788 diag::err_intel_sycl_ptr_annotation_mismatch)
7793 for (; I <= NumArgs / 2; ++I) {
7797 if (!isa<StringLiteral>(Arg) &&
7800 diag::err_intel_sycl_ptr_annotation_mismatch)
7807 for (; I != NumArgs; ++I) {
7809 if (BuiltinConstantArg(TheCall, I, Result))
7814 TheCall->
setType(PointerArgType);
7820 assert(VD &&
"Expecting valid declaration");
7822 assert(SpecializationId &&
"Expecting a non-null SpecializationId");
7823 assert(SpecializationId->
getKind() == APValue::ValueKind::Struct &&
7824 "Expecting SpecializationId to be of kind Struct");
7826 "Expecting SpecializationId to have a single field for the default "
7829 assert(
Default.isInt() &&
"Expecting the default value to be an integer");
7833 bool Sema::CheckIntelSYCLAllocaBuiltinFunctionCall(
unsigned BuiltinID,
7835 assert(getLangOpts().SYCLIsDevice &&
7836 "Builtin can only be used in SYCL device code");
7838 assert((BuiltinID == Builtin::BI__builtin_intel_sycl_alloca ||
7839 BuiltinID == Builtin::BI__builtin_intel_sycl_alloca_with_align) &&
7840 "Unexpected builtin");
7842 bool IsAlignedAlloca =
7843 BuiltinID == Builtin::BI__builtin_intel_sycl_alloca_with_align;
7845 constexpr
unsigned InvalidIndex = -1;
7846 constexpr
unsigned ElementTypeIndex = 0;
7847 const unsigned AlignmentIndex = IsAlignedAlloca ? 1 : InvalidIndex;
7848 const unsigned SpecNameIndex = IsAlignedAlloca ? 2 : 1;
7855 assert(FD &&
"Builtin cannot be called from a function pointer");
7856 if (!FD->
hasAttr<BuiltinAliasAttr>()) {
7857 Diag(Loc, diag::err_intel_sycl_alloca_no_alias) << IsAlignedAlloca;
7866 unsigned DesiredTemplateArgumentsCount = IsAlignedAlloca ? 4 : 3;
7868 if (!CST || CST->
size() != DesiredTemplateArgumentsCount) {
7869 Diag(Loc, diag::err_intel_sycl_alloca_wrong_template_arg_count)
7870 << IsAlignedAlloca << (CST ? CST->
size() : 0);
7875 constexpr
auto CheckArg = [](
QualType Ty) {
7883 Diag(Loc, diag::err_intel_sycl_alloca_wrong_arg)
7897 ->getTemplateArgs();
7906 Diag(Loc, diag::err_intel_sycl_alloca_wrong_type)
7912 const auto CheckSize = [
this, IsAlignedAlloca, ElementTypeIndex,
7925 ->getTemplateArgs();
7930 if (DefaultSize < 1)
7931 Diag(Loc, diag::warn_intel_sycl_alloca_bad_default_value)
7932 << IsAlignedAlloca << DefaultSize.getSExtValue();
7935 if (CheckSize(getASTContext(), Loc, CST)) {
7938 const SemaDiagnosticBuilder &D =
7939 Diag(Loc, diag::err_intel_sycl_alloca_wrong_size);
7940 D << IsAlignedAlloca;
7948 if (IsAlignedAlloca) {
7951 if (!RequestedAlign.isPowerOf2())
7952 return Diag(Loc, diag::err_alignment_not_power_of_two);
7954 if (RequestedAlign > MaxAllowedAlign)
7955 return Diag(Loc, diag::err_alignment_too_big) << MaxAllowedAlign;
7957 int64_t AllocaRequiredAlignment =
7959 if (RequestedAlign < AllocaRequiredAlignment)
7960 return Diag(Loc, diag::err_alignas_underaligned)
7961 << AllocaType << AllocaRequiredAlignment;
7972 if (Format->getFirstArg() == 0)
7974 else if (IsVariadic)
7978 FSI->
FormatIdx = Format->getFormatIdx() - 1;
7980 FSI->
ArgPassingKind == FAPK_VAList ? 0 : Format->getFirstArg() - 1;
8002 if (isa<CXXNullPtrLiteralExpr>(
8017 if (
const auto *CLE = dyn_cast<CompoundLiteralExpr>(
Expr))
8018 if (
const auto *ILE = dyn_cast<InitListExpr>(CLE->getInitializer()))
8019 Expr = ILE->getInit(0);
8029 const Expr *ArgExpr,
8033 S.
PDiag(diag::warn_null_arg)
8039 if ((GetFormatStringType(Format) == FST_NSString) &&
8040 getFormatStringInfo(Format,
false,
true, &FSI)) {
8055 bool Format =
false;
8068 if (!Format || NumArgs <= Idx)
8070 const Expr *FormatExpr = Args[Idx];
8071 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
8072 FormatExpr = CSCE->getSubExpr();
8082 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
8091 if (
auto nullability =
type->getNullability())
8102 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
8108 llvm::SmallBitVector NonNullArgs;
8114 for (
const auto *Arg : Args)
8121 unsigned IdxAST = Idx.getASTIndex();
8122 if (IdxAST >= Args.size())
8124 if (NonNullArgs.empty())
8125 NonNullArgs.resize(Args.size());
8126 NonNullArgs.set(IdxAST);
8131 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
8135 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
8138 parms = cast<ObjCMethodDecl>(FDecl)->parameters();
8140 unsigned ParamIndex = 0;
8142 I != E; ++I, ++ParamIndex) {
8145 if (NonNullArgs.empty())
8146 NonNullArgs.resize(Args.size());
8148 NonNullArgs.set(ParamIndex);
8155 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
8160 type = blockType->getPointeeType();
8174 if (NonNullArgs.empty())
8175 NonNullArgs.resize(Args.size());
8177 NonNullArgs.set(Index);
8186 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
8187 ArgIndex != ArgIndexEnd; ++ArgIndex) {
8188 if (NonNullArgs[ArgIndex])
8201 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
8205 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
8209 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
8210 if (!PD || !PD->getType()->isRecordType())
8216 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
8221 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
8232 StringRef ParamName,
QualType ArgTy,
8260 if (ArgAlign < ParamAlign)
8261 Diag(Loc, diag::warn_param_mismatched_alignment)
8263 << ParamName << (FDecl !=
nullptr) << FDecl;
8274 if (CurContext->isDependentContext())
8278 llvm::SmallBitVector CheckedVarArgs;
8282 CheckedVarArgs.resize(Args.size());
8284 CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
8291 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
8292 if (CallType != VariadicDoesNotApply &&
8295 : FDecl && isa<FunctionDecl>(FDecl)
8296 ? cast<FunctionDecl>(FDecl)->getNumParams()
8297 : FDecl && isa<ObjCMethodDecl>(FDecl)
8298 ? cast<ObjCMethodDecl>(FDecl)->param_size()
8301 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
8303 if (
const Expr *Arg = Args[ArgIdx]) {
8304 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
8305 checkVariadicArgument(Arg, CallType);
8310 if (FDecl || Proto) {
8315 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
8316 CheckArgumentWithTypeTag(I, Args, Loc);
8322 if (!Proto && FDecl) {
8324 if (isa_and_nonnull<FunctionProtoType>(FT))
8330 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
8332 bool IsScalableArg =
false;
8333 for (
unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
8335 if (
const Expr *Arg = Args[ArgIdx]) {
8342 CallType == VariadicDoesNotApply)
8343 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
8347 IsScalableArg =
true;
8349 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
8358 if (
auto *CallerFD = dyn_cast<FunctionDecl>(CurContext)) {
8359 llvm::StringMap<bool> CallerFeatureMap;
8361 if (!CallerFeatureMap.contains(
"sme"))
8362 Diag(Loc, diag::err_sme_call_in_non_sme_target);
8364 Diag(Loc, diag::err_sme_call_in_non_sme_target);
8371 const auto *CallerFD = dyn_cast<FunctionDecl>(CurContext);
8373 (IsScalableArg || IsScalableRet)) {
8374 bool IsCalleeStreaming =
8376 bool IsCalleeStreamingCompatible =
8380 if (!IsCalleeStreamingCompatible &&
8382 ((CallerFnType ==
ArmStreaming) ^ IsCalleeStreaming))) {
8384 Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8387 Diag(Loc, diag::warn_sme_streaming_pass_return_vl_to_non_streaming)
8398 bool CallerHasZAState =
false;
8399 bool CallerHasZT0State =
false;
8401 auto *
Attr = CallerFD->getAttr<ArmNewAttr>();
8403 CallerHasZAState =
true;
8405 CallerHasZT0State =
true;
8409 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8411 CallerHasZT0State |=
8413 FPT->getExtProtoInfo().AArch64SMEAttributes) !=
8419 Diag(Loc, diag::err_sme_za_call_no_za_state);
8422 Diag(Loc, diag::err_sme_zt0_call_no_zt0_state);
8426 Diag(Loc, diag::err_sme_unimplemented_za_save_restore);
8427 Diag(Loc, diag::note_sme_use_preserves_za);
8432 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
8433 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
8434 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
8435 if (!Arg->isValueDependent()) {
8437 if (Arg->EvaluateAsInt(Align, Context)) {
8439 if (!I.isPowerOf2())
8440 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
8441 << Arg->getSourceRange();
8444 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
8451 diagnoseArgDependentDiagnoseIfAttrs(FD, ThisArg, Args, Loc);
8453 if (FD && FD->
hasAttr<SYCLKernelAttr>())
8454 SYCL().CheckSYCLKernelCall(FD, Args);
8457 if (FD && FD->
isVariadic() && getLangOpts().SYCLIsDevice &&
8458 !isUnevaluatedContext() && !SYCL().isDeclAllowedInSYCLDeviceCode(FD))
8459 SYCL().DiagIfDeviceCode(Loc, diag::err_sycl_restrict)
8469 VariadicCallType CallType =
8470 Proto->
isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
8472 auto *Ctor = cast<CXXConstructorDecl>(FDecl);
8477 checkCall(FDecl, Proto,
nullptr, Args,
true,
8485 bool IsMemberOperatorCall = isa<CXXOperatorCallExpr>(TheCall) &&
8486 isa<CXXMethodDecl>(FDecl);
8487 bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
8488 IsMemberOperatorCall;
8494 Expr *ImplicitThis =
nullptr;
8499 ImplicitThis = Args[0];
8502 }
else if (IsMemberFunction && !FDecl->
isStatic() &&
8505 cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
8517 cast<CXXMethodDecl>(FDecl)->getFunctionObjectParameterType());
8519 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
8523 checkCall(FDecl, Proto, ImplicitThis,
llvm::ArrayRef(Args, NumArgs),
8535 CheckTCBEnforcement(TheCall->
getExprLoc(), FDecl);
8537 CheckAbsoluteValueFunction(TheCall, FDecl);
8538 CheckMaxUnsignedZero(TheCall, FDecl);
8539 CheckInfNaNFunction(TheCall, FDecl);
8541 if (getLangOpts().ObjC)
8550 case Builtin::BIstrlcpy:
8551 case Builtin::BIstrlcat:
8552 CheckStrlcpycatArguments(TheCall, FnInfo);
8554 case Builtin::BIstrncat:
8555 CheckStrncatArguments(TheCall, FnInfo);
8557 case Builtin::BIfree:
8558 CheckFreeArguments(TheCall);
8561 CheckMemaccessArguments(TheCall, CMId, FnInfo);
8569 VariadicCallType CallType =
8570 Method->
isVariadic() ? VariadicMethod : VariadicDoesNotApply;
8572 checkCall(Method,
nullptr,
nullptr, Args,
8576 CheckTCBEnforcement(lbrac, Method);
8584 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
8585 Ty =
V->getType().getNonReferenceType();
8586 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
8587 Ty = F->getType().getNonReferenceType();
8595 VariadicCallType CallType;
8597 CallType = VariadicDoesNotApply;
8599 CallType = VariadicBlock;
8601 CallType = VariadicFunction;
8604 checkCall(NDecl, Proto,
nullptr,
8615 VariadicCallType CallType = getVariadicCallType(
nullptr, Proto,
8617 checkCall(
nullptr, Proto,
nullptr,
8626 if (!llvm::isValidAtomicOrderingCABI(Ordering))
8629 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
8631 case AtomicExpr::AO__c11_atomic_init:
8632 case AtomicExpr::AO__opencl_atomic_init:
8633 llvm_unreachable(
"There is no ordering argument for an init");
8635 case AtomicExpr::AO__c11_atomic_load:
8636 case AtomicExpr::AO__opencl_atomic_load:
8637 case AtomicExpr::AO__hip_atomic_load:
8638 case AtomicExpr::AO__atomic_load_n:
8639 case AtomicExpr::AO__atomic_load:
8640 case AtomicExpr::AO__scoped_atomic_load_n:
8641 case AtomicExpr::AO__scoped_atomic_load:
8642 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
8643 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8645 case AtomicExpr::AO__c11_atomic_store:
8646 case AtomicExpr::AO__opencl_atomic_store:
8647 case AtomicExpr::AO__hip_atomic_store:
8648 case AtomicExpr::AO__atomic_store:
8649 case AtomicExpr::AO__atomic_store_n:
8650 case AtomicExpr::AO__scoped_atomic_store:
8651 case AtomicExpr::AO__scoped_atomic_store_n:
8652 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
8653 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
8654 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
8663 CallExpr *TheCall = cast<CallExpr>(TheCallResult.
get());
8707 const unsigned NumForm = GNUCmpXchg + 1;
8708 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
8709 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
8717 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
8718 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
8719 "need to update code for modified forms");
8720 static_assert(AtomicExpr::AO__atomic_add_fetch == 0 &&
8721 AtomicExpr::AO__atomic_xor_fetch + 1 ==
8722 AtomicExpr::AO__c11_atomic_compare_exchange_strong,
8723 "need to update code for modified C11 atomics");
8724 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_compare_exchange_strong &&
8725 Op <= AtomicExpr::AO__opencl_atomic_store;
8726 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_compare_exchange_strong &&
8727 Op <= AtomicExpr::AO__hip_atomic_store;
8728 bool IsScoped = Op >= AtomicExpr::AO__scoped_atomic_add_fetch &&
8729 Op <= AtomicExpr::AO__scoped_atomic_xor_fetch;
8730 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_compare_exchange_strong &&
8731 Op <= AtomicExpr::AO__c11_atomic_store) ||
8733 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
8734 Op == AtomicExpr::AO__atomic_store_n ||
8735 Op == AtomicExpr::AO__atomic_exchange_n ||
8736 Op == AtomicExpr::AO__atomic_compare_exchange_n ||
8737 Op == AtomicExpr::AO__scoped_atomic_load_n ||
8738 Op == AtomicExpr::AO__scoped_atomic_store_n ||
8739 Op == AtomicExpr::AO__scoped_atomic_exchange_n ||
8740 Op == AtomicExpr::AO__scoped_atomic_compare_exchange_n;
8744 enum ArithOpExtraValueType {
8749 unsigned ArithAllows = AOEVT_None;
8752 case AtomicExpr::AO__c11_atomic_init:
8753 case AtomicExpr::AO__opencl_atomic_init:
8757 case AtomicExpr::AO__c11_atomic_load:
8758 case AtomicExpr::AO__opencl_atomic_load:
8759 case AtomicExpr::AO__hip_atomic_load:
8760 case AtomicExpr::AO__atomic_load_n:
8761 case AtomicExpr::AO__scoped_atomic_load_n:
8765 case AtomicExpr::AO__atomic_load:
8766 case AtomicExpr::AO__scoped_atomic_load:
8770 case AtomicExpr::AO__c11_atomic_store:
8771 case AtomicExpr::AO__opencl_atomic_store:
8772 case AtomicExpr::AO__hip_atomic_store:
8773 case AtomicExpr::AO__atomic_store:
8774 case AtomicExpr::AO__atomic_store_n:
8775 case AtomicExpr::AO__scoped_atomic_store:
8776 case AtomicExpr::AO__scoped_atomic_store_n:
8779 case AtomicExpr::AO__atomic_fetch_add:
8780 case AtomicExpr::AO__atomic_fetch_sub:
8781 case AtomicExpr::AO__atomic_add_fetch:
8782 case AtomicExpr::AO__atomic_sub_fetch:
8783 case AtomicExpr::AO__scoped_atomic_fetch_add:
8784 case AtomicExpr::AO__scoped_atomic_fetch_sub:
8785 case AtomicExpr::AO__scoped_atomic_add_fetch:
8786 case AtomicExpr::AO__scoped_atomic_sub_fetch:
8787 case AtomicExpr::AO__c11_atomic_fetch_add:
8788 case AtomicExpr::AO__c11_atomic_fetch_sub:
8789 case AtomicExpr::AO__opencl_atomic_fetch_add:
8790 case AtomicExpr::AO__opencl_atomic_fetch_sub:
8791 case AtomicExpr::AO__hip_atomic_fetch_add:
8792 case AtomicExpr::AO__hip_atomic_fetch_sub:
8793 ArithAllows = AOEVT_Pointer | AOEVT_FP;
8796 case AtomicExpr::AO__atomic_fetch_max:
8797 case AtomicExpr::AO__atomic_fetch_min:
8798 case AtomicExpr::AO__atomic_max_fetch:
8799 case AtomicExpr::AO__atomic_min_fetch:
8800 case AtomicExpr::AO__scoped_atomic_fetch_max:
8801 case AtomicExpr::AO__scoped_atomic_fetch_min:
8802 case AtomicExpr::AO__scoped_atomic_max_fetch:
8803 case AtomicExpr::AO__scoped_atomic_min_fetch:
8804 case AtomicExpr::AO__c11_atomic_fetch_max:
8805 case AtomicExpr::AO__c11_atomic_fetch_min:
8806 case AtomicExpr::AO__opencl_atomic_fetch_max:
8807 case AtomicExpr::AO__opencl_atomic_fetch_min:
8808 case AtomicExpr::AO__hip_atomic_fetch_max:
8809 case AtomicExpr::AO__hip_atomic_fetch_min:
8810 ArithAllows = AOEVT_FP;
8813 case AtomicExpr::AO__c11_atomic_fetch_and:
8814 case AtomicExpr::AO__c11_atomic_fetch_or:
8815 case AtomicExpr::AO__c11_atomic_fetch_xor:
8816 case AtomicExpr::AO__hip_atomic_fetch_and:
8817 case AtomicExpr::AO__hip_atomic_fetch_or:
8818 case AtomicExpr::AO__hip_atomic_fetch_xor:
8819 case AtomicExpr::AO__c11_atomic_fetch_nand:
8820 case AtomicExpr::AO__opencl_atomic_fetch_and:
8821 case AtomicExpr::AO__opencl_atomic_fetch_or:
8822 case AtomicExpr::AO__opencl_atomic_fetch_xor:
8823 case AtomicExpr::AO__atomic_fetch_and:
8824 case AtomicExpr::AO__atomic_fetch_or:
8825 case AtomicExpr::AO__atomic_fetch_xor:
8826 case AtomicExpr::AO__atomic_fetch_nand:
8827 case AtomicExpr::AO__atomic_and_fetch:
8828 case AtomicExpr::AO__atomic_or_fetch:
8829 case AtomicExpr::AO__atomic_xor_fetch:
8830 case AtomicExpr::AO__atomic_nand_fetch:
8831 case AtomicExpr::AO__scoped_atomic_fetch_and:
8832 case AtomicExpr::AO__scoped_atomic_fetch_or:
8833 case AtomicExpr::AO__scoped_atomic_fetch_xor:
8834 case AtomicExpr::AO__scoped_atomic_fetch_nand:
8835 case AtomicExpr::AO__scoped_atomic_and_fetch:
8836 case AtomicExpr::AO__scoped_atomic_or_fetch:
8837 case AtomicExpr::AO__scoped_atomic_xor_fetch:
8838 case AtomicExpr::AO__scoped_atomic_nand_fetch:
8842 case AtomicExpr::AO__c11_atomic_exchange:
8843 case AtomicExpr::AO__hip_atomic_exchange:
8844 case AtomicExpr::AO__opencl_atomic_exchange:
8845 case AtomicExpr::AO__atomic_exchange_n:
8846 case AtomicExpr::AO__scoped_atomic_exchange_n:
8850 case AtomicExpr::AO__atomic_exchange:
8851 case AtomicExpr::AO__scoped_atomic_exchange:
8855 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
8856 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
8857 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
8858 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
8859 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
8860 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
8864 case AtomicExpr::AO__atomic_compare_exchange:
8865 case AtomicExpr::AO__atomic_compare_exchange_n:
8866 case AtomicExpr::AO__scoped_atomic_compare_exchange:
8867 case AtomicExpr::AO__scoped_atomic_compare_exchange_n:
8872 unsigned AdjustedNumArgs = NumArgs[Form];
8873 if ((IsOpenCL || IsHIP || IsScoped) &&
8874 Op != AtomicExpr::AO__opencl_atomic_init)
8877 if (Args.size() < AdjustedNumArgs) {
8878 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
8879 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8882 }
else if (Args.size() > AdjustedNumArgs) {
8883 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
8884 diag::err_typecheck_call_too_many_args)
8885 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
8891 Expr *Ptr = Args[0];
8892 ExprResult ConvertedPtr = DefaultFunctionArrayLvalueConversion(Ptr);
8896 Ptr = ConvertedPtr.
get();
8899 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
8909 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
8915 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
8921 }
else if (Form !=
Load && Form != LoadCopy) {
8923 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
8930 if (Form == Arithmetic) {
8933 auto IsAllowedValueType = [&](
QualType ValType,
8934 unsigned AllowedType) ->
bool {
8938 return AllowedType & AOEVT_Pointer;
8944 &llvm::APFloat::x87DoubleExtended())
8948 if (!IsAllowedValueType(ValType, ArithAllows)) {
8949 auto DID = ArithAllows & AOEVT_FP
8950 ? (ArithAllows & AOEVT_Pointer
8951 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
8952 : diag::err_atomic_op_needs_atomic_int_or_fp)
8953 : diag::err_atomic_op_needs_atomic_int;
8960 diag::err_incomplete_type)) {
8966 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
8977 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
8993 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
9005 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
9007 ResultType = Context.
VoidTy;
9008 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
9009 ResultType = Context.
BoolTy;
9014 bool IsPassedByAddress =
false;
9015 if (!IsC11 && !IsHIP && !IsN) {
9017 IsPassedByAddress =
true;
9022 APIOrderedArgs.push_back(Args[0]);
9026 APIOrderedArgs.push_back(Args[1]);
9032 APIOrderedArgs.push_back(Args[2]);
9033 APIOrderedArgs.push_back(Args[1]);
9036 APIOrderedArgs.push_back(Args[2]);
9037 APIOrderedArgs.push_back(Args[3]);
9038 APIOrderedArgs.push_back(Args[1]);
9041 APIOrderedArgs.push_back(Args[2]);
9042 APIOrderedArgs.push_back(Args[4]);
9043 APIOrderedArgs.push_back(Args[1]);
9044 APIOrderedArgs.push_back(Args[3]);
9047 APIOrderedArgs.push_back(Args[2]);
9048 APIOrderedArgs.push_back(Args[4]);
9049 APIOrderedArgs.push_back(Args[5]);
9050 APIOrderedArgs.push_back(Args[1]);
9051 APIOrderedArgs.push_back(Args[3]);
9055 APIOrderedArgs.append(Args.begin(), Args.end());
9062 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
9064 if (i < NumVals[Form] + 1) {
9077 assert(Form !=
Load);
9080 else if (Form == Init || Form == Arithmetic)
9082 else if (Form ==
Copy || Form == Xchg) {
9083 if (IsPassedByAddress) {
9090 Expr *ValArg = APIOrderedArgs[i];
9097 AS = PtrTy->getPointeeType().getAddressSpace();
9106 if (IsPassedByAddress)
9126 APIOrderedArgs[i] = Arg.
get();
9131 SubExprs.push_back(Ptr);
9135 SubExprs.push_back(APIOrderedArgs[1]);
9138 SubExprs.push_back(APIOrderedArgs[1]);
9144 SubExprs.push_back(APIOrderedArgs[2]);
9145 SubExprs.push_back(APIOrderedArgs[1]);
9149 SubExprs.push_back(APIOrderedArgs[3]);
9150 SubExprs.push_back(APIOrderedArgs[1]);
9151 SubExprs.push_back(APIOrderedArgs[2]);
9154 SubExprs.push_back(APIOrderedArgs[3]);
9155 SubExprs.push_back(APIOrderedArgs[1]);
9156 SubExprs.push_back(APIOrderedArgs[4]);
9157 SubExprs.push_back(APIOrderedArgs[2]);
9160 SubExprs.push_back(APIOrderedArgs[4]);
9161 SubExprs.push_back(APIOrderedArgs[1]);
9162 SubExprs.push_back(APIOrderedArgs[5]);
9163 SubExprs.push_back(APIOrderedArgs[2]);
9164 SubExprs.push_back(APIOrderedArgs[3]);
9169 if (SubExprs.size() >= 2 && Form != Init) {
9170 std::optional<llvm::APSInt> Success =
9171 SubExprs[1]->getIntegerConstantExpr(Context);
9173 Diag(SubExprs[1]->getBeginLoc(),
9174 diag::warn_atomic_op_has_invalid_memory_order)
9175 << (Form == C11CmpXchg || Form == GNUCmpXchg)
9178 if (SubExprs.size() >= 5) {
9179 if (std::optional<llvm::APSInt> Failure =
9180 SubExprs[3]->getIntegerConstantExpr(Context)) {
9181 if (!llvm::is_contained(
9182 {llvm::AtomicOrderingCABI::relaxed,
9183 llvm::AtomicOrderingCABI::consume,
9184 llvm::AtomicOrderingCABI::acquire,
9185 llvm::AtomicOrderingCABI::seq_cst},
9186 (llvm::AtomicOrderingCABI)Failure->getSExtValue())) {
9187 Diag(SubExprs[3]->getBeginLoc(),
9188 diag::warn_atomic_op_has_invalid_memory_order)
9189 << 2 << SubExprs[3]->getSourceRange();
9196 auto *
Scope = Args[Args.size() - 1];
9197 if (std::optional<llvm::APSInt> Result =
9198 Scope->getIntegerConstantExpr(Context)) {
9199 if (!ScopeModel->isValid(Result->getZExtValue()))
9200 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
9201 <<
Scope->getSourceRange();
9203 SubExprs.push_back(
Scope);
9209 if ((Op == AtomicExpr::AO__c11_atomic_load ||
9210 Op == AtomicExpr::AO__c11_atomic_store ||
9211 Op == AtomicExpr::AO__opencl_atomic_load ||
9212 Op == AtomicExpr::AO__hip_atomic_load ||
9213 Op == AtomicExpr::AO__opencl_atomic_store ||
9214 Op == AtomicExpr::AO__hip_atomic_store) &&
9217 << ((Op == AtomicExpr::AO__c11_atomic_load ||
9218 Op == AtomicExpr::AO__opencl_atomic_load ||
9219 Op == AtomicExpr::AO__hip_atomic_load)
9224 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
9240 assert(Fn &&
"builtin call without direct callee!");
9255 bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
9264 bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
9299 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9301 <<
Callee->getSourceRange();
9311 ExprResult FirstArgResult = DefaultFunctionArrayLvalueConversion(FirstArg);
9314 FirstArg = FirstArgResult.
get();
9315 TheCall->
setArg(0, FirstArg);
9327 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
9362 #define BUILTIN_ROW(x) \
9363 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
9364 Builtin::BI##x##_8, Builtin::BI##x##_16 }
9366 static const unsigned BuiltinIndices[][5] = {
9392 case 1: SizeIndex = 0;
break;
9393 case 2: SizeIndex = 1;
break;
9394 case 4: SizeIndex = 2;
break;
9395 case 8: SizeIndex = 3;
break;
9396 case 16: SizeIndex = 4;
break;
9408 unsigned BuiltinIndex, NumFixed = 1;
9409 bool WarnAboutSemanticsChange =
false;
9410 switch (BuiltinID) {
9411 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
9412 case Builtin::BI__sync_fetch_and_add:
9413 case Builtin::BI__sync_fetch_and_add_1:
9414 case Builtin::BI__sync_fetch_and_add_2:
9415 case Builtin::BI__sync_fetch_and_add_4:
9416 case Builtin::BI__sync_fetch_and_add_8:
9417 case Builtin::BI__sync_fetch_and_add_16:
9421 case Builtin::BI__sync_fetch_and_sub:
9422 case Builtin::BI__sync_fetch_and_sub_1:
9423 case Builtin::BI__sync_fetch_and_sub_2:
9424 case Builtin::BI__sync_fetch_and_sub_4:
9425 case Builtin::BI__sync_fetch_and_sub_8:
9426 case Builtin::BI__sync_fetch_and_sub_16:
9430 case Builtin::BI__sync_fetch_and_or:
9431 case Builtin::BI__sync_fetch_and_or_1:
9432 case Builtin::BI__sync_fetch_and_or_2:
9433 case Builtin::BI__sync_fetch_and_or_4:
9434 case Builtin::BI__sync_fetch_and_or_8:
9435 case Builtin::BI__sync_fetch_and_or_16:
9439 case Builtin::BI__sync_fetch_and_and:
9440 case Builtin::BI__sync_fetch_and_and_1:
9441 case Builtin::BI__sync_fetch_and_and_2:
9442 case Builtin::BI__sync_fetch_and_and_4:
9443 case Builtin::BI__sync_fetch_and_and_8:
9444 case Builtin::BI__sync_fetch_and_and_16:
9448 case Builtin::BI__sync_fetch_and_xor:
9449 case Builtin::BI__sync_fetch_and_xor_1:
9450 case Builtin::BI__sync_fetch_and_xor_2:
9451 case Builtin::BI__sync_fetch_and_xor_4:
9452 case Builtin::BI__sync_fetch_and_xor_8:
9453 case Builtin::BI__sync_fetch_and_xor_16:
9457 case Builtin::BI__sync_fetch_and_nand:
9458 case Builtin::BI__sync_fetch_and_nand_1:
9459 case Builtin::BI__sync_fetch_and_nand_2:
9460 case Builtin::BI__sync_fetch_and_nand_4:
9461 case Builtin::BI__sync_fetch_and_nand_8:
9462 case Builtin::BI__sync_fetch_and_nand_16:
9464 WarnAboutSemanticsChange =
true;
9467 case Builtin::BI__sync_add_and_fetch:
9468 case Builtin::BI__sync_add_and_fetch_1:
9469 case Builtin::BI__sync_add_and_fetch_2:
9470 case Builtin::BI__sync_add_and_fetch_4:
9471 case Builtin::BI__sync_add_and_fetch_8:
9472 case Builtin::BI__sync_add_and_fetch_16:
9476 case Builtin::BI__sync_sub_and_fetch:
9477 case Builtin::BI__sync_sub_and_fetch_1:
9478 case Builtin::BI__sync_sub_and_fetch_2:
9479 case Builtin::BI__sync_sub_and_fetch_4:
9480 case Builtin::BI__sync_sub_and_fetch_8:
9481 case Builtin::BI__sync_sub_and_fetch_16:
9485 case Builtin::BI__sync_and_and_fetch:
9486 case Builtin::BI__sync_and_and_fetch_1:
9487 case Builtin::BI__sync_and_and_fetch_2:
9488 case Builtin::BI__sync_and_and_fetch_4:
9489 case Builtin::BI__sync_and_and_fetch_8:
9490 case Builtin::BI__sync_and_and_fetch_16:
9494 case Builtin::BI__sync_or_and_fetch:
9495 case Builtin::BI__sync_or_and_fetch_1:
9496 case Builtin::BI__sync_or_and_fetch_2:
9497 case Builtin::BI__sync_or_and_fetch_4:
9498 case Builtin::BI__sync_or_and_fetch_8:
9499 case Builtin::BI__sync_or_and_fetch_16:
9503 case Builtin::BI__sync_xor_and_fetch:
9504 case Builtin::BI__sync_xor_and_fetch_1:
9505 case Builtin::BI__sync_xor_and_fetch_2:
9506 case Builtin::BI__sync_xor_and_fetch_4:
9507 case Builtin::BI__sync_xor_and_fetch_8:
9508 case Builtin::BI__sync_xor_and_fetch_16:
9512 case Builtin::BI__sync_nand_and_fetch:
9513 case Builtin::BI__sync_nand_and_fetch_1:
9514 case Builtin::BI__sync_nand_and_fetch_2:
9515 case Builtin::BI__sync_nand_and_fetch_4:
9516 case Builtin::BI__sync_nand_and_fetch_8:
9517 case Builtin::BI__sync_nand_and_fetch_16:
9519 WarnAboutSemanticsChange =
true;
9522 case Builtin::BI__sync_val_compare_and_swap:
9523 case Builtin::BI__sync_val_compare_and_swap_1:
9524 case Builtin::BI__sync_val_compare_and_swap_2:
9525 case Builtin::BI__sync_val_compare_and_swap_4:
9526 case Builtin::BI__sync_val_compare_and_swap_8:
9527 case Builtin::BI__sync_val_compare_and_swap_16:
9532 case Builtin::BI__sync_bool_compare_and_swap:
9533 case Builtin::BI__sync_bool_compare_and_swap_1:
9534 case Builtin::BI__sync_bool_compare_and_swap_2:
9535 case Builtin::BI__sync_bool_compare_and_swap_4:
9536 case Builtin::BI__sync_bool_compare_and_swap_8:
9537 case Builtin::BI__sync_bool_compare_and_swap_16:
9540 ResultType = Context.
BoolTy;
9543 case Builtin::BI__sync_lock_test_and_set:
9544 case Builtin::BI__sync_lock_test_and_set_1:
9545 case Builtin::BI__sync_lock_test_and_set_2:
9546 case Builtin::BI__sync_lock_test_and_set_4:
9547 case Builtin::BI__sync_lock_test_and_set_8:
9548 case Builtin::BI__sync_lock_test_and_set_16:
9552 case Builtin::BI__sync_lock_release:
9553 case Builtin::BI__sync_lock_release_1:
9554 case Builtin::BI__sync_lock_release_2:
9555 case Builtin::BI__sync_lock_release_4:
9556 case Builtin::BI__sync_lock_release_8:
9557 case Builtin::BI__sync_lock_release_16:
9560 ResultType = Context.
VoidTy;
9563 case Builtin::BI__sync_swap:
9564 case Builtin::BI__sync_swap_1:
9565 case Builtin::BI__sync_swap_2:
9566 case Builtin::BI__sync_swap_4:
9567 case Builtin::BI__sync_swap_8:
9568 case Builtin::BI__sync_swap_16:
9576 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
9577 << 0 << 1 + NumFixed << TheCall->
getNumArgs() << 0
9578 <<
Callee->getSourceRange();
9582 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
9583 <<
Callee->getSourceRange();
9585 if (WarnAboutSemanticsChange) {
9586 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
9587 <<
Callee->getSourceRange();
9592 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
9595 if (NewBuiltinID == BuiltinID)
9596 NewBuiltinDecl = FDecl;
9601 LookupName(Res, TUScope,
true);
9602 assert(Res.getFoundDecl());
9603 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
9604 if (!NewBuiltinDecl)
9611 for (
unsigned i = 0; i != NumFixed; ++i) {
9641 ExprResult PromotedCall = ImpCastExprToType(NewDRE, CalleePtrTy,
9642 CK_BuiltinFnToFnPtr);
9654 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
9655 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
9659 return TheCallResult;
9674 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
9675 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
9676 "Unexpected nontemporal load/store builtin!");
9677 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
9678 unsigned numArgs = isStore ? 2 : 1;
9688 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
9690 DefaultFunctionArrayLvalueConversion(PointerArg);
9694 PointerArg = PointerArgResult.
get();
9695 TheCall->
setArg(numArgs - 1, PointerArg);
9699 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
9712 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
9719 return TheCallResult;
9724 Context, ValType,
false);
9725 ValArg = PerformCopyInitialization(Entity,
SourceLocation(), ValArg);
9731 return TheCallResult;
9738 bool Sema::CheckObjCString(
Expr *Arg) {
9743 Diag(Arg->
getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
9748 if (
Literal->containsNonAsciiOrNull()) {
9749 StringRef String =
Literal->getString();
9750 unsigned NumBytes = String.size();
9752 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
9753 llvm::UTF16 *ToPtr = &ToBuf[0];
9755 llvm::ConversionResult Result =
9756 llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
9757 ToPtr + NumBytes, llvm::strictConversion);
9759 if (Result != llvm::conversionOK)
9770 auto *
Literal = dyn_cast<StringLiteral>(Arg);
9772 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
9773 Literal = ObjcLiteral->getString();
9787 Result = PerformCopyInitialization(Entity,
SourceLocation(), Result);
9795 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
9796 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
9797 TT.getArch() == llvm::Triple::aarch64_32);
9798 bool IsWindows = TT.isOSWindows();
9799 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
9800 if (IsX64 || IsAArch64) {
9808 diag::err_ms_va_start_used_in_sysv_function);
9817 diag::err_va_start_used_in_wrong_abi_function)
9832 bool IsVariadic =
false;
9835 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
9836 IsVariadic =
Block->isVariadic();
9837 Params =
Block->parameters();
9838 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
9841 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
9842 IsVariadic = MD->isVariadic();
9844 Params = MD->parameters();
9845 }
else if (isa<CapturedDecl>(Caller)) {
9861 *LastParam = Params.empty() ? nullptr : Params.back();
9869 bool Sema::BuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
9894 bool SecondArgIsLastNamedArgument =
false;
9896 if (std::optional<llvm::APSInt> Val =
9898 Val && LangOpts.C23 && *Val == 0)
9905 bool IsCRegister =
false;
9907 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
9908 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
9909 SecondArgIsLastNamedArgument = PV == LastParam;
9911 Type = PV->getType();
9912 ParamLoc = PV->getLocation();
9914 PV->getStorageClass() ==
SC_Register && !getLangOpts().CPlusPlus;
9918 if (!SecondArgIsLastNamedArgument)
9920 diag::warn_second_arg_of_va_start_not_last_named_param);
9925 if (!Context.isPromotableIntegerType(Type))
9927 if (!Type->isEnumeralType())
9929 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
9931 Context.typesAreCompatible(ED->getPromotionType(), Type));
9933 unsigned Reason = 0;
9935 else if (IsCRegister) Reason = 2;
9936 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
9937 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
9943 bool Sema::BuiltinVAStartARMMicrosoft(
CallExpr *Call) {
9944 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
9964 if (
Call->getNumArgs() < 3)
9966 diag::err_typecheck_call_too_few_args_at_least)
9967 << 0 << 3 <<
Call->getNumArgs()
9980 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
9983 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
9988 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
9990 << Arg1->
getType() << ConstCharPtrTy << 1
9993 << 2 << Arg1->
getType() << ConstCharPtrTy;
9998 << Arg2->
getType() << SizeTy << 1
10001 << 3 << Arg2->
getType() << SizeTy;
10008 bool Sema::BuiltinUnorderedCompare(
CallExpr *TheCall,
unsigned BuiltinID) {
10012 if (BuiltinID == Builtin::BI__builtin_isunordered &&
10022 QualType Res = UsualArithmeticConversions(
10023 OrigArg0, OrigArg1, TheCall->
getExprLoc(), ACK_Comparison);
10040 diag::err_typecheck_call_invalid_ordered_compare)
10051 bool Sema::BuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs,
10052 unsigned BuiltinID) {
10057 if (FPO.getNoHonorInfs() && (BuiltinID == Builtin::BI__builtin_isfinite ||
10058 BuiltinID == Builtin::BI__builtin_isinf ||
10059 BuiltinID == Builtin::BI__builtin_isinf_sign))
10063 if (FPO.getNoHonorNaNs() && (BuiltinID == Builtin::BI__builtin_isnan ||
10064 BuiltinID == Builtin::BI__builtin_isunordered))
10068 bool IsFPClass = NumArgs == 2;
10071 unsigned FPArgNo = IsFPClass ? 0 : NumArgs - 1;
10075 for (
unsigned i = 0; i < FPArgNo; ++i) {
10081 ExprResult Res = PerformImplicitConversion(Arg, Context.
IntTy, AA_Passing);
10097 OrigArg = UsualUnaryConversions(OrigArg).get();
10099 OrigArg = DefaultFunctionArrayLvalueConversion(OrigArg).get();
10100 TheCall->
setArg(FPArgNo, OrigArg);
10107 VectorResultTy = GetSignedVectorType(ElementTy);
10114 diag::err_typecheck_call_invalid_unary_fp)
10120 if (BuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
10126 if (!VectorResultTy.
isNull())
10127 ResultTy = VectorResultTy;
10129 ResultTy = Context.
IntTy;
10137 bool Sema::BuiltinComplex(
CallExpr *TheCall) {
10141 bool Dependent =
false;
10142 for (
unsigned I = 0; I != 2; ++I) {
10153 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
10157 ExprResult Converted = DefaultLvalueConversion(Arg);
10172 diag::err_typecheck_call_different_arg_types)
10198 bool Sema::BuiltinVSX(
CallExpr *TheCall) {
10199 unsigned ExpectedNumArgs = 3;
10206 diag::err_vsx_builtin_nonconstant_argument)
10218 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
10226 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
10245 diag::err_typecheck_call_too_few_args_at_least)
10253 unsigned numElements = 0;
10268 unsigned numResElements = TheCall->
getNumArgs() - 2;
10277 diag::err_vec_builtin_incompatible_vector)
10284 diag::err_vec_builtin_incompatible_vector)
10289 }
else if (numElements != numResElements) {
10296 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
10301 std::optional<llvm::APSInt> Result;
10304 diag::err_shufflevector_nonconstant_argument)
10308 if (Result->isSigned() && Result->isAllOnes())
10311 if (Result->getActiveBits() > 64 ||
10312 Result->getZExtValue() >= numElements * 2)
10314 diag::err_shufflevector_argument_too_large)
10320 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
10321 exprs.push_back(TheCall->
getArg(i));
10322 TheCall->
setArg(i,
nullptr);
10341 diag::err_convertvector_non_vector)
10344 return ExprError(
Diag(BuiltinLoc, diag::err_builtin_non_vector_type)
10346 <<
"__builtin_convertvector");
10351 if (SrcElts != DstElts)
10353 diag::err_convertvector_incompatible_vector)
10358 BuiltinLoc, RParenLoc);
10364 bool Sema::BuiltinPrefetch(
CallExpr *TheCall) {
10372 for (
unsigned i = 1; i != NumArgs; ++i)
10373 if (BuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
10380 bool Sema::BuiltinArithmeticFence(
CallExpr *TheCall) {
10382 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
10392 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
10395 ExprResult FirstArg = DefaultLvalueConversion(Arg);
10405 bool Sema::BuiltinAssume(
CallExpr *TheCall) {
10412 << cast<FunctionDecl>(TheCall->
getCalleeDecl())->getIdentifier();
10420 bool Sema::BuiltinAllocaWithAlign(
CallExpr *TheCall) {
10426 if (
const auto *UE =
10428 if (UE->getKind() == UETT_AlignOf ||
10429 UE->getKind() == UETT_PreferredAlignOf)
10435 if (!Result.isPowerOf2())
10436 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10453 bool Sema::BuiltinAssumeAligned(
CallExpr *TheCall) {
10462 DefaultFunctionArrayLvalueConversion(FirstArg);
10466 TheCall->
setArg(0, FirstArgResult.
get());
10475 if (BuiltinConstantArg(TheCall, 1, Result))
10478 if (!Result.isPowerOf2())
10479 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
10491 TheCall->
setArg(2, ThirdArg);
10497 bool Sema::BuiltinOSLogFormat(
CallExpr *TheCall) {
10498 unsigned BuiltinID =
10499 cast<FunctionDecl>(TheCall->
getCalleeDecl())->getBuiltinID();
10500 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
10503 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
10504 if (NumArgs < NumRequiredArgs) {
10505 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
10506 << 0 << NumRequiredArgs << NumArgs
10519 if (Arg.isInvalid())
10521 TheCall->
setArg(i, Arg.get());
10526 unsigned FormatIdx = i;
10536 unsigned FirstDataArg = i;
10537 while (i < NumArgs) {
10538 ExprResult Arg = DefaultVariadicArgumentPromotion(
10539 TheCall->
getArg(i), VariadicFunction,
nullptr);
10555 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
10557 bool Success = CheckFormatArguments(
10558 Args, FAPK_Variadic, FormatIdx, FirstDataArg, FST_OSLog,
10575 bool Sema::BuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
10583 std::optional<llvm::APSInt> R;
10585 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
10593 bool Sema::BuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
int Low,
10594 int High,
bool RangeIsError) {
10595 if (isConstantEvaluatedContext())
10605 if (BuiltinConstantArg(TheCall, ArgNum, Result))
10608 if (Result.getSExtValue() < Low || Result.getSExtValue() > High) {
10610 return Diag(TheCall->
getBeginLoc(), diag::err_argument_invalid_range)
10615 DiagRuntimeBehavior(TheCall->
getBeginLoc(), TheCall,
10616 PDiag(diag::warn_argument_invalid_range)
10617 <<
toString(Result, 10) << Low << High
10626 bool Sema::BuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
10636 if (BuiltinConstantArg(TheCall, ArgNum, Result))
10639 if (Result.getSExtValue() % Num != 0)
10648 bool Sema::BuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
10657 if (BuiltinConstantArg(TheCall, ArgNum, Result))
10662 if (Result.isStrictlyPositive() && (Result & (Result - 1)) == 0)
10665 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
10670 if (
Value.isNegative())
10681 if ((
Value & 0xFF) != 0)
10694 bool Sema::BuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
10695 unsigned ArgBits) {
10704 if (BuiltinConstantArg(TheCall, ArgNum, Result))
10708 Result = Result.getLoBits(ArgBits);
10709 Result.setIsUnsigned(
true);
10714 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
10723 bool Sema::BuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
int ArgNum,
10724 unsigned ArgBits) {
10733 if (BuiltinConstantArg(TheCall, ArgNum, Result))
10737 Result = Result.getLoBits(ArgBits);
10738 Result.setIsUnsigned(
true);
10742 (Result > 0 && Result < 0x10000 && (Result & 0xFF) == 0xFF))
10746 diag::err_argument_not_shifted_byte_or_xxff)
10751 bool Sema::BuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
10752 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
10758 ExprResult FirstArg = DefaultFunctionArrayLvalueConversion(Arg0);
10763 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10767 ExprResult SecArg = DefaultLvalueConversion(Arg1);
10772 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10776 TheCall->
setType(FirstArgType);
10780 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
10785 ExprResult FirstArg = DefaultFunctionArrayLvalueConversion(Arg0);
10790 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10795 TheCall->
setType(FirstArgType);
10798 return BuiltinConstantArgRange(TheCall, 1, 0, 15);
10801 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
10807 ExprResult FirstArg = DefaultFunctionArrayLvalueConversion(Arg0);
10812 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10817 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
10823 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
10824 BuiltinID == AArch64::BI__builtin_arm_stg) {
10828 ExprResult FirstArg = DefaultFunctionArrayLvalueConversion(Arg0);
10834 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
10839 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
10840 TheCall->
setType(FirstArgType);
10844 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
10848 ExprResult ArgExprA = DefaultFunctionArrayLvalueConversion(ArgA);
10849 ExprResult ArgExprB = DefaultFunctionArrayLvalueConversion(ArgB);
10857 auto isNull = [&] (
Expr *E) ->
bool {
10863 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10867 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
10878 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
10886 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_any2arg_pointer)
10890 ArgExprA = ImpCastExprToType(ArgExprA.
get(), ArgTypeB, CK_NullToPointer);
10893 ArgExprB = ImpCastExprToType(ArgExprB.
get(), ArgTypeA, CK_NullToPointer);
10900 assert(
false &&
"Unhandled ARM MTE intrinsic");
10906 bool Sema::BuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
10907 int ArgNum,
unsigned ExpectedFieldNum,
10909 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
10910 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
10911 BuiltinID == ARM::BI__builtin_arm_rsr ||
10912 BuiltinID == ARM::BI__builtin_arm_rsrp ||
10913 BuiltinID == ARM::BI__builtin_arm_wsr ||
10914 BuiltinID == ARM::BI__builtin_arm_wsrp;
10915 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
10916 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
10917 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10918 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
10919 BuiltinID == AArch64::BI__builtin_arm_rsr ||
10920 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
10921 BuiltinID == AArch64::BI__builtin_arm_wsr ||
10922 BuiltinID == AArch64::BI__builtin_arm_wsrp;
10923 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
10932 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
10938 Reg.split(Fields,
":");
10940 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
10941 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10948 if (Fields.size() > 1) {
10949 bool FiveFields = Fields.size() == 5;
10951 bool ValidString =
true;
10952 if (IsARMBuiltin) {
10953 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
10954 Fields[0].starts_with_insensitive(
"p");
10956 Fields[0] = Fields[0].drop_front(
10957 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
10959 ValidString &= Fields[2].starts_with_insensitive(
"c");
10961 Fields[2] = Fields[2].drop_front(1);
10964 ValidString &= Fields[3].starts_with_insensitive(
"c");
10966 Fields[3] = Fields[3].drop_front(1);
10972 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
10974 Ranges.append({15, 7, 15});
10976 for (
unsigned i=0; i<Fields.size(); ++i) {
10978 ValidString &= !Fields[i].getAsInteger(10, IntField);
10979 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
10983 return Diag(TheCall->
getBeginLoc(), diag::err_arm_invalid_specialreg)
10985 }
else if (IsAArch64Builtin && Fields.size() == 1) {
10993 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
10994 BuiltinID == AArch64::BI__builtin_arm_wsr128)
10999 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
11000 .CaseLower(
"spsel", 15)
11001 .CaseLower(
"daifclr", 15)
11002 .CaseLower(
"daifset", 15)
11003 .CaseLower(
"pan", 15)
11004 .CaseLower(
"uao", 15)
11005 .CaseLower(
"dit", 15)
11006 .CaseLower(
"ssbs", 15)
11007 .CaseLower(
"tco", 15)
11008 .CaseLower(
"allint", 1)
11009 .CaseLower(
"pm", 1)
11010 .Default(std::nullopt);
11030 return BuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
11040 bool Sema::BuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
11041 const char *TypeStr) {
11043 assert((TypeStr[0] !=
'\0') &&
11044 "Invalid types in PPC MMA builtin declaration");
11047 unsigned ArgNum = 0;
11054 while (*TypeStr !=
'\0') {
11078 diag::err_typecheck_convert_incompatible)
11084 if (Mask != 0 && BuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
11094 while (*TypeStr !=
'\0') {
11107 bool Sema::BuiltinLongjmp(
CallExpr *TheCall) {
11109 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
11116 if (BuiltinConstantArg(TheCall, 1, Result))
11120 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
11128 bool Sema::BuiltinSetjmp(
CallExpr *TheCall) {
11130 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
11137 class UncoveredArgHandler {
11138 enum {
Unknown = -1, AllCovered = -2 };
11140 signed FirstUncoveredArg =
Unknown;
11144 UncoveredArgHandler() =
default;
11146 bool hasUncoveredArg()
const {
11147 return (FirstUncoveredArg >= 0);
11150 unsigned getUncoveredArg()
const {
11151 assert(hasUncoveredArg() &&
"no uncovered argument");
11152 return FirstUncoveredArg;
11155 void setAllCovered() {
11158 DiagnosticExprs.clear();
11159 FirstUncoveredArg = AllCovered;
11162 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
11163 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
11166 if (FirstUncoveredArg == AllCovered)
11171 if (NewFirstUncoveredArg == FirstUncoveredArg)
11172 DiagnosticExprs.push_back(StrExpr);
11173 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
11174 DiagnosticExprs.clear();
11175 DiagnosticExprs.push_back(StrExpr);
11176 FirstUncoveredArg = NewFirstUncoveredArg;
11180 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
11183 enum StringLiteralCheckType {
11185 SLCT_UncheckedLiteral,
11186 SLCT_CheckedLiteral
11193 bool AddendIsRight) {
11194 unsigned BitWidth =
Offset.getBitWidth();
11195 unsigned AddendBitWidth = Addend.getBitWidth();
11197 if (Addend.isUnsigned()) {
11198 Addend = Addend.zext(++AddendBitWidth);
11199 Addend.setIsSigned(
true);
11202 if (AddendBitWidth > BitWidth) {
11204 BitWidth = AddendBitWidth;
11205 }
else if (BitWidth > AddendBitWidth) {
11206 Addend = Addend.sext(BitWidth);
11211 if (BinOpKind == BO_Add)
11212 ResOffset =
Offset.sadd_ov(Addend, Ov);
11214 assert(AddendIsRight && BinOpKind == BO_Sub &&
11215 "operator must be add or sub with addend on the right");
11216 ResOffset =
Offset.ssub_ov(Addend, Ov);
11223 "index (intermediate) result too big");
11237 class FormatStringLiteral {
11245 StringRef getString()
const {
11249 unsigned getByteLength()
const {
11260 bool isAscii()
const {
return FExpr->
isOrdinary(); }
11261 bool isWide()
const {
return FExpr->
isWide(); }
11262 bool isUTF8()
const {
return FExpr->
isUTF8(); }
11263 bool isUTF16()
const {
return FExpr->
isUTF16(); }
11264 bool isUTF32()
const {
return FExpr->
isUTF32(); }
11265 bool isPascal()
const {
return FExpr->
isPascal(); }
11270 unsigned *StartTokenByteOffset =
nullptr)
const {
11272 StartToken, StartTokenByteOffset);
11285 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
11289 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
11290 bool IgnoreStringsWithoutSpecifiers);
11296 static StringLiteralCheckType
11301 llvm::SmallBitVector &CheckedVarArgs,
11303 bool IgnoreStringsWithoutSpecifiers =
false) {
11305 return SLCT_NotALiteral;
11307 assert(
Offset.isSigned() &&
"invalid offset");
11310 return SLCT_NotALiteral;
11319 return SLCT_UncheckedLiteral;
11322 case Stmt::InitListExprClass:
11326 Type, CallType,
false,
11327 CheckedVarArgs, UncoveredArg,
Offset,
11328 IgnoreStringsWithoutSpecifiers);
11330 return SLCT_NotALiteral;
11331 case Stmt::BinaryConditionalOperatorClass:
11332 case Stmt::ConditionalOperatorClass: {
11336 cast<AbstractConditionalOperator>(E);
11341 bool CheckLeft =
true, CheckRight =
true;
11344 if (C->getCond()->EvaluateAsBooleanCondition(
11347 CheckRight =
false;
11356 StringLiteralCheckType Left;
11358 Left = SLCT_UncheckedLiteral;
11361 firstDataArg,
Type, CallType, InFunctionCall,
11362 CheckedVarArgs, UncoveredArg,
Offset,
11363 IgnoreStringsWithoutSpecifiers);
11364 if (Left == SLCT_NotALiteral || !CheckRight) {
11370 S, C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
11371 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
11372 IgnoreStringsWithoutSpecifiers);
11374 return (CheckLeft && Left < Right) ? Left : Right;
11377 case Stmt::ImplicitCastExprClass:
11378 E = cast<ImplicitCastExpr>(E)->getSubExpr();
11381 case Stmt::OpaqueValueExprClass:
11382 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
11386 return SLCT_NotALiteral;
11388 case Stmt::PredefinedExprClass:
11392 return SLCT_UncheckedLiteral;
11394 case Stmt::DeclRefExprClass: {
11400 bool isConstant =
false;
11404 isConstant = AT->getElementType().isConstant(S.
Context);
11406 isConstant =
T.isConstant(S.
Context) &&
11411 isConstant =
T.isConstant(S.
Context);
11415 if (
const Expr *Init = VD->getAnyInitializer()) {
11417 if (
const InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
11418 if (InitList->isStringLiteralInit())
11419 Init = InitList->getInit(0)->IgnoreParenImpCasts();
11422 S, Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
11423 false, CheckedVarArgs, UncoveredArg,
Offset);
11464 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
11465 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
11466 for (
const auto *PVFormat : D->specific_attrs<FormatAttr>()) {
11467 bool IsCXXMember =
false;
11468 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
11469 IsCXXMember = MD->isInstance();
11471 bool IsVariadic =
false;
11473 IsVariadic = cast<FunctionProtoType>(FnTy)->isVariadic();
11474 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
11475 IsVariadic = BD->isVariadic();
11476 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
11477 IsVariadic = OMD->isVariadic();
11484 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
11497 return SLCT_UncheckedLiteral;
11506 return SLCT_NotALiteral;
11509 case Stmt::CallExprClass:
11510 case Stmt::CXXMemberCallExprClass: {
11511 const CallExpr *CE = cast<CallExpr>(E);
11513 bool IsFirst =
true;
11514 StringLiteralCheckType CommonResult;
11515 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
11516 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
11518 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11519 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
11520 IgnoreStringsWithoutSpecifiers);
11522 CommonResult = Result;
11527 return CommonResult;
11529 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
11531 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
11532 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
11535 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11536 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
11537 IgnoreStringsWithoutSpecifiers);
11543 Type, CallType,
false,
11544 CheckedVarArgs, UncoveredArg,
Offset,
11545 IgnoreStringsWithoutSpecifiers);
11546 return SLCT_NotALiteral;
11548 case Stmt::ObjCMessageExprClass: {
11549 const auto *ME = cast<ObjCMessageExpr>(E);
11550 if (
const auto *MD = ME->getMethodDecl()) {
11551 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
11560 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
11562 MD->getSelector().isKeywordSelector(
11563 {
"localizedStringForKey",
"value",
"table"})) {
11564 IgnoreStringsWithoutSpecifiers =
true;
11567 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
11569 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
11570 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
11571 IgnoreStringsWithoutSpecifiers);
11575 return SLCT_NotALiteral;
11577 case Stmt::ObjCStringLiteralClass:
11578 case Stmt::StringLiteralClass: {
11584 StrE = cast<StringLiteral>(E);
11590 return SLCT_NotALiteral;
11592 FormatStringLiteral FStr(StrE,
Offset.sextOrTrunc(64).getSExtValue());
11594 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
11595 IgnoreStringsWithoutSpecifiers);
11596 return SLCT_CheckedLiteral;
11599 return SLCT_NotALiteral;
11601 case Stmt::BinaryOperatorClass: {
11615 if (LIsInt != RIsInt) {
11619 if (BinOpKind == BO_Add) {
11632 return SLCT_NotALiteral;
11634 case Stmt::UnaryOperatorClass: {
11636 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
11637 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
11639 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
11644 E = ASE->getBase();
11649 return SLCT_NotALiteral;
11653 return SLCT_NotALiteral;
11664 const auto *LVE = Result.Val.getLValueBase().dyn_cast<
const Expr *>();
11665 if (isa_and_nonnull<StringLiteral>(LVE))
11672 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
11673 .Case(
"scanf", FST_Scanf)
11674 .Cases(
"printf",
"printf0", FST_Printf)
11675 .Cases(
"NSString",
"CFString", FST_NSString)
11676 .Case(
"strftime", FST_Strftime)
11677 .Case(
"strfmon", FST_Strfmon)
11678 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err", FST_Kprintf)
11679 .Case(
"freebsd_kprintf", FST_FreeBSDKPrintf)
11680 .Case(
"os_trace", FST_OSLog)
11681 .Case(
"os_log", FST_OSLog)
11682 .Default(FST_Unknown);
11688 bool Sema::CheckFormatArguments(
const FormatAttr *Format,
11692 llvm::SmallBitVector &CheckedVarArgs) {
11693 FormatStringInfo FSI;
11694 if (getFormatStringInfo(Format, IsCXXMember, CallType != VariadicDoesNotApply,
11696 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
11697 FSI.FirstDataArg, GetFormatStringType(Format),
11698 CallType, Loc, Range, CheckedVarArgs);
11704 unsigned format_idx,
unsigned firstDataArg,
11705 FormatStringType
Type,
11708 llvm::SmallBitVector &CheckedVarArgs) {
11710 if (format_idx >= Args.size()) {
11711 Diag(Loc, diag::warn_missing_format_string) << Range;
11715 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
11729 UncoveredArgHandler UncoveredArg;
11731 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
11733 true, CheckedVarArgs, UncoveredArg,
11737 if (UncoveredArg.hasUncoveredArg()) {
11738 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
11739 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
11740 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
11743 if (CT != SLCT_NotALiteral)
11745 return CT == SLCT_CheckedLiteral;
11749 if (
Type == FST_Strftime)
11757 if (
Type == FST_NSString && SourceMgr.isInSystemMacro(FormatLoc))
11762 if (Args.size() == firstDataArg) {
11763 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
11769 case FST_FreeBSDKPrintf:
11771 Diag(FormatLoc, diag::note_format_security_fixit)
11775 Diag(FormatLoc, diag::note_format_security_fixit)
11780 Diag(FormatLoc, diag::warn_format_nonliteral)
11791 const FormatStringLiteral *FExpr;
11792 const Expr *OrigFormatExpr;
11794 const unsigned FirstDataArg;
11795 const unsigned NumDataArgs;
11799 unsigned FormatIdx;
11800 llvm::SmallBitVector CoveredArgs;
11801 bool usesPositionalArgs =
false;
11802 bool atFirstArg =
true;
11803 bool inFunctionCall;
11805 llvm::SmallBitVector &CheckedVarArgs;
11806 UncoveredArgHandler &UncoveredArg;
11809 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11810 const Expr *origFormatExpr,
11812 unsigned numDataArgs,
const char *beg,
11816 llvm::SmallBitVector &CheckedVarArgs,
11817 UncoveredArgHandler &UncoveredArg)
11818 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(
type),
11819 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
11820 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
11821 inFunctionCall(inFunctionCall), CallType(callType),
11822 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
11823 CoveredArgs.resize(numDataArgs);
11824 CoveredArgs.reset();
11827 void DoneProcessing();
11829 void HandleIncompleteSpecifier(
const char *startSpecifier,
11830 unsigned specifierLen)
override;
11832 void HandleInvalidLengthModifier(
11835 const char *startSpecifier,
unsigned specifierLen,
11838 void HandleNonStandardLengthModifier(
11840 const char *startSpecifier,
unsigned specifierLen);
11842 void HandleNonStandardConversionSpecifier(
11844 const char *startSpecifier,
unsigned specifierLen);
11846 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
11848 void HandleInvalidPosition(
const char *startSpecifier,
11849 unsigned specifierLen,
11852 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
11854 void HandleNullChar(
const char *nullCharacter)
override;
11856 template <
typename Range>
11858 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
11860 bool IsStringLocation, Range StringRange,
11864 bool HandleInvalidConversionSpecifier(
unsigned argIndex,
SourceLocation Loc,
11865 const char *startSpec,
11866 unsigned specifierLen,
11867 const char *csStart,
unsigned csLen);
11870 const char *startSpec,
11871 unsigned specifierLen);
11875 unsigned specifierLen);
11878 const Expr *getDataArg(
unsigned i)
const;
11882 const char *startSpecifier,
unsigned specifierLen,
11883 unsigned argIndex);
11885 template <
typename Range>
11887 bool IsStringLocation, Range StringRange,
11893 SourceRange CheckFormatHandler::getFormatStringRange() {
11898 getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
11908 SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
11913 void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
11914 unsigned specifierLen){
11915 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
11916 getLocationOfByte(startSpecifier),
11918 getSpecifierRange(startSpecifier, specifierLen));
11921 void CheckFormatHandler::HandleInvalidLengthModifier(
11924 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
11925 using namespace analyze_format_string;
11927 const LengthModifier &LM = FS.getLengthModifier();
11928 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11931 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11933 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11934 getLocationOfByte(LM.getStart()),
11936 getSpecifierRange(startSpecifier, specifierLen));
11938 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11939 << FixedLM->toString()
11944 if (DiagID == diag::warn_format_nonsensical_length)
11947 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
11948 getLocationOfByte(LM.getStart()),
11950 getSpecifierRange(startSpecifier, specifierLen),
11955 void CheckFormatHandler::HandleNonStandardLengthModifier(
11957 const char *startSpecifier,
unsigned specifierLen) {
11958 using namespace analyze_format_string;
11960 const LengthModifier &LM = FS.getLengthModifier();
11961 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
11964 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
11966 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11967 << LM.toString() << 0,
11968 getLocationOfByte(LM.getStart()),
11970 getSpecifierRange(startSpecifier, specifierLen));
11972 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
11973 << FixedLM->toString()
11977 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11978 << LM.toString() << 0,
11979 getLocationOfByte(LM.getStart()),
11981 getSpecifierRange(startSpecifier, specifierLen));
11985 void CheckFormatHandler::HandleNonStandardConversionSpecifier(
11987 const char *startSpecifier,
unsigned specifierLen) {
11988 using namespace analyze_format_string;
11993 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
11997 getSpecifierRange(startSpecifier, specifierLen));
12000 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
12001 << FixedCS->toString()
12004 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
12008 getSpecifierRange(startSpecifier, specifierLen));
12012 void CheckFormatHandler::HandlePosition(
const char *startPos,
12014 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
12015 getLocationOfByte(startPos),
12017 getSpecifierRange(startPos, posLen));
12020 void CheckFormatHandler::HandleInvalidPosition(
12021 const char *startSpecifier,
unsigned specifierLen,
12023 EmitFormatDiagnostic(
12024 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
12025 getLocationOfByte(startSpecifier),
true,
12026 getSpecifierRange(startSpecifier, specifierLen));
12029 void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
12031 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
12032 getLocationOfByte(startPos),
12034 getSpecifierRange(startPos, posLen));
12037 void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
12038 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
12040 EmitFormatDiagnostic(
12041 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
12042 getLocationOfByte(nullCharacter),
true,
12043 getFormatStringRange());
12049 const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
12050 return Args[FirstDataArg + i];
12053 void CheckFormatHandler::DoneProcessing() {
12058 CoveredArgs.flip();
12059 signed notCoveredArg = CoveredArgs.find_first();
12060 if (notCoveredArg >= 0) {
12061 assert((
unsigned)notCoveredArg < NumDataArgs);
12062 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
12064 UncoveredArg.setAllCovered();
12069 void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
12070 const Expr *ArgExpr) {
12071 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
12083 for (
auto E : DiagnosticExprs)
12086 CheckFormatHandler::EmitFormatDiagnostic(
12087 S, IsFunctionCall, DiagnosticExprs[0],
12093 CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
12095 const char *startSpec,
12096 unsigned specifierLen,
12097 const char *csStart,
12099 bool keepGoing =
true;
12100 if (argIndex < NumDataArgs) {
12103 CoveredArgs.set(argIndex);
12119 std::string CodePointStr;
12120 if (!llvm::sys::locale::isPrint(*csStart)) {
12121 llvm::UTF32 CodePoint;
12122 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
12123 const llvm::UTF8 *E =
12124 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
12125 llvm::ConversionResult Result =
12126 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
12128 if (Result != llvm::conversionOK) {
12129 unsigned char FirstChar = *csStart;
12130 CodePoint = (llvm::UTF32)FirstChar;
12133 llvm::raw_string_ostream OS(CodePointStr);
12134 if (CodePoint < 256)
12135 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
12136 else if (CodePoint <= 0xFFFF)
12137 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
12139 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
12144 EmitFormatDiagnostic(
12145 S.
PDiag(diag::warn_format_invalid_conversion) <<
Specifier, Loc,
12146 true, getSpecifierRange(startSpec, specifierLen));
12152 CheckFormatHandler::HandlePositionalNonpositionalArgs(
SourceLocation Loc,
12153 const char *startSpec,
12154 unsigned specifierLen) {
12155 EmitFormatDiagnostic(
12156 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
12157 Loc,
true, getSpecifierRange(startSpec, specifierLen));
12161 CheckFormatHandler::CheckNumArgs(
12164 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
12166 if (argIndex >= NumDataArgs) {
12168 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
12169 << (argIndex+1) << NumDataArgs)
12170 : S.
PDiag(diag::warn_printf_insufficient_data_args);
12171 EmitFormatDiagnostic(
12172 PDiag, getLocationOfByte(CS.
getStart()),
true,
12173 getSpecifierRange(startSpecifier, specifierLen));
12177 UncoveredArg.setAllCovered();
12183 template<
typename Range>
12186 bool IsStringLocation,
12189 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
12190 Loc, IsStringLocation, StringRange,
FixIt);
12220 template <
typename Range>
12221 void CheckFormatHandler::EmitFormatDiagnostic(
12222 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
12225 if (InFunctionCall) {
12226 const Sema::SemaDiagnosticBuilder &D = S.
Diag(Loc, PDiag);
12230 S.
Diag(IsStringLocation ? ArgumentExpr->
getExprLoc() : Loc, PDiag)
12233 const Sema::SemaDiagnosticBuilder &
Note =
12234 S.
Diag(IsStringLocation ? Loc : StringRange.getBegin(),
12235 diag::note_format_string_defined);
12237 Note << StringRange;
12246 class CheckPrintfHandler :
public CheckFormatHandler {
12248 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
12249 const Expr *origFormatExpr,
12251 unsigned numDataArgs,
bool isObjC,
const char *beg,
12255 llvm::SmallBitVector &CheckedVarArgs,
12256 UncoveredArgHandler &UncoveredArg)
12257 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
12258 numDataArgs, beg, APK, Args, formatIdx,
12259 inFunctionCall, CallType, CheckedVarArgs,
12265 bool allowsObjCArg()
const {
12270 bool HandleInvalidPrintfConversionSpecifier(
12272 const char *startSpecifier,
12273 unsigned specifierLen)
override;
12275 void handleInvalidMaskType(StringRef MaskType)
override;
12278 const char *startSpecifier,
unsigned specifierLen,
12281 const char *StartSpecifier,
12282 unsigned SpecifierLen,
12286 const char *startSpecifier,
unsigned specifierLen);
12288 const analyze_printf::OptionalAmount &Amt,
12290 const char *startSpecifier,
unsigned specifierLen);
12292 const analyze_printf::OptionalFlag &flag,
12293 const char *startSpecifier,
unsigned specifierLen);
12295 const analyze_printf::OptionalFlag &ignoredFlag,
12296 const analyze_printf::OptionalFlag &flag,
12297 const char *startSpecifier,
unsigned specifierLen);
12298 bool checkForCStrMembers(
const analyze_printf::ArgType &AT,
12301 void HandleEmptyObjCModifierFlag(
const char *startFlag,
12302 unsigned flagLen)
override;
12304 void HandleInvalidObjCModifierFlag(
const char *startFlag,
12305 unsigned flagLen)
override;
12307 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
12308 const char *flagsEnd,
12309 const char *conversionPosition)
12315 bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
12317 const char *startSpecifier,
12318 unsigned specifierLen) {
12320 FS.getConversionSpecifier();
12322 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
12324 startSpecifier, specifierLen,
12328 void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
12329 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
12332 bool CheckPrintfHandler::HandleAmount(
12334 const char *startSpecifier,
unsigned specifierLen) {
12338 if (argIndex >= NumDataArgs) {
12339 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
12341 getLocationOfByte(Amt.
getStart()),
12343 getSpecifierRange(startSpecifier, specifierLen));
12353 CoveredArgs.set(argIndex);
12354 const Expr *Arg = getDataArg(argIndex);
12361 assert(AT.isValid());
12363 if (!AT.matchesType(S.
Context,
T)) {
12364 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
12365 << k << AT.getRepresentativeTypeName(S.
Context)
12367 getLocationOfByte(Amt.
getStart()),
12369 getSpecifierRange(startSpecifier, specifierLen));
12379 void CheckPrintfHandler::HandleInvalidAmount(
12381 const analyze_printf::OptionalAmount &Amt,
12383 const char *startSpecifier,
12384 unsigned specifierLen) {
12386 FS.getConversionSpecifier();
12391 Amt.getConstantLength()))
12394 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
12396 getLocationOfByte(Amt.getStart()),
12398 getSpecifierRange(startSpecifier, specifierLen),
12403 const analyze_printf::OptionalFlag &flag,
12404 const char *startSpecifier,
12405 unsigned specifierLen) {
12408 FS.getConversionSpecifier();
12409 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
12410 << flag.toString() << CS.
toString(),
12411 getLocationOfByte(flag.getPosition()),
12413 getSpecifierRange(startSpecifier, specifierLen),
12415 getSpecifierRange(flag.getPosition(), 1)));
12418 void CheckPrintfHandler::HandleIgnoredFlag(
12420 const analyze_printf::OptionalFlag &ignoredFlag,
12421 const analyze_printf::OptionalFlag &flag,
12422 const char *startSpecifier,
12423 unsigned specifierLen) {
12425 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
12426 << ignoredFlag.toString() << flag.toString(),
12427 getLocationOfByte(ignoredFlag.getPosition()),
12429 getSpecifierRange(startSpecifier, specifierLen),
12431 getSpecifierRange(ignoredFlag.getPosition(), 1)));
12434 void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
12435 unsigned flagLen) {
12437 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
12438 getLocationOfByte(startFlag),
12440 getSpecifierRange(startFlag, flagLen));
12443 void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
12444 unsigned flagLen) {
12446 auto Range = getSpecifierRange(startFlag, flagLen);
12447 StringRef flag(startFlag, flagLen);
12448 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
12449 getLocationOfByte(startFlag),
12454 void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
12455 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
12457 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
12458 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
12459 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
12460 getLocationOfByte(conversionPosition),
12468 template<
typename MemberKind>
12489 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
12490 Results.insert(FK);
12502 MethodSet Results =
12503 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", *
this, E->
getType());
12504 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12506 if ((*MI)->getMinRequiredArguments() == 0)
12514 bool CheckPrintfHandler::checkForCStrMembers(
12518 MethodSet Results =
12519 CXXRecordMembersNamed<CXXMethodDecl>(
"c_str", S, E->
getType());
12521 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
12537 bool CheckPrintfHandler::HandlePrintfSpecifier(
12540 using namespace analyze_format_string;
12541 using namespace analyze_printf;
12543 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
12545 if (FS.consumesDataArgument()) {
12547 atFirstArg =
false;
12548 usesPositionalArgs = FS.usesPositionalArg();
12550 else if (usesPositionalArgs != FS.usesPositionalArg()) {
12551 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
12552 startSpecifier, specifierLen);
12559 if (!HandleAmount(FS.getFieldWidth(), 0,
12560 startSpecifier, specifierLen)) {
12564 if (!HandleAmount(FS.getPrecision(), 1,
12565 startSpecifier, specifierLen)) {
12569 if (!CS.consumesDataArgument()) {
12576 unsigned argIndex = FS.getArgIndex();
12577 if (argIndex < NumDataArgs) {
12581 CoveredArgs.set(argIndex);
12585 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
12586 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
12588 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
12592 CoveredArgs.set(argIndex + 1);
12595 const Expr *Ex = getDataArg(argIndex);
12596 const analyze_printf::ArgType &AT =
12597 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
12600 EmitFormatDiagnostic(
12601 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12605 getSpecifierRange(startSpecifier, specifierLen));
12608 Ex = getDataArg(argIndex + 1);
12609 const analyze_printf::ArgType &AT2 = ArgType::CStrTy;
12610 if (AT2.isValid() && !AT2.matchesType(S.
Context, Ex->
getType()))
12611 EmitFormatDiagnostic(
12612 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
12616 getSpecifierRange(startSpecifier, specifierLen));
12623 if (!allowsObjCArg() && CS.isObjCArg()) {
12624 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12629 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
12630 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12635 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
12636 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
12637 getLocationOfByte(CS.getStart()),
12639 getSpecifierRange(startSpecifier, specifierLen));
12646 (CS.getKind() == ConversionSpecifier::PArg ||
12647 CS.getKind() == ConversionSpecifier::sArg ||
12648 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
12649 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
12655 if (FS.isPublic().isSet()) {
12656 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12658 getLocationOfByte(FS.isPublic().getPosition()),
12660 getSpecifierRange(startSpecifier, specifierLen));
12662 if (FS.isPrivate().isSet()) {
12663 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
12665 getLocationOfByte(FS.isPrivate().getPosition()),
12667 getSpecifierRange(startSpecifier, specifierLen));
12671 const llvm::Triple &Triple =
Target.getTriple();
12672 if (CS.getKind() == ConversionSpecifier::nArg &&
12673 (Triple.isAndroid() || Triple.isOSFuchsia())) {
12674 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
12675 getLocationOfByte(CS.getStart()),
12677 getSpecifierRange(startSpecifier, specifierLen));
12681 if (!FS.hasValidFieldWidth()) {
12682 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
12683 startSpecifier, specifierLen);
12687 if (!FS.hasValidPrecision()) {
12688 HandleInvalidAmount(FS, FS.getPrecision(), 1,
12689 startSpecifier, specifierLen);
12693 if (CS.getKind() == ConversionSpecifier::PArg &&
12694 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
12695 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
12696 getLocationOfByte(startSpecifier),
12698 getSpecifierRange(startSpecifier, specifierLen));
12702 if (!FS.hasValidThousandsGroupingPrefix())
12703 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
12704 if (!FS.hasValidLeadingZeros())
12705 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
12706 if (!FS.hasValidPlusPrefix())
12707 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
12708 if (!FS.hasValidSpacePrefix())
12709 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
12710 if (!FS.hasValidAlternativeForm())
12711 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
12712 if (!FS.hasValidLeftJustified())
12713 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
12716 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
12717 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
12718 startSpecifier, specifierLen);
12719 if (FS.hasLeadingZeros() && FS.isLeftJustified())
12720 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
12721 startSpecifier, specifierLen);
12726 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12727 diag::warn_format_nonsensical_length);
12728 else if (!FS.hasStandardLengthModifier())
12729 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
12730 else if (!FS.hasStandardLengthConversionCombination())
12731 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
12732 diag::warn_format_non_standard_conversion_spec);
12734 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
12735 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
12741 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
12744 const Expr *Arg = getDataArg(argIndex);
12748 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
12760 case Stmt::ArraySubscriptExprClass:
12761 case Stmt::CallExprClass:
12762 case Stmt::CharacterLiteralClass:
12763 case Stmt::CXXBoolLiteralExprClass:
12764 case Stmt::DeclRefExprClass:
12765 case Stmt::FloatingLiteralClass:
12766 case Stmt::IntegerLiteralClass:
12767 case Stmt::MemberExprClass:
12768 case Stmt::ObjCArrayLiteralClass:
12769 case Stmt::ObjCBoolLiteralExprClass:
12770 case Stmt::ObjCBoxedExprClass:
12771 case Stmt::ObjCDictionaryLiteralClass:
12772 case Stmt::ObjCEncodeExprClass:
12773 case Stmt::ObjCIvarRefExprClass:
12774 case Stmt::ObjCMessageExprClass:
12775 case Stmt::ObjCPropertyRefExprClass:
12776 case Stmt::ObjCStringLiteralClass:
12777 case Stmt::ObjCSubscriptRefExprClass:
12778 case Stmt::ParenExprClass:
12779 case Stmt::StringLiteralClass:
12780 case Stmt::UnaryOperatorClass:
12787 static std::pair<QualType, StringRef>
12794 StringRef Name = UserTy->getDecl()->getName();
12795 QualType CastTy = llvm::StringSwitch<QualType>(Name)
12799 .Case(
"SInt32", Context.
IntTy)
12804 return std::make_pair(CastTy, Name);
12806 TyTy = UserTy->desugar();
12810 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
12812 PE->getSubExpr()->getType(),
12821 StringRef TrueName, FalseName;
12823 std::tie(TrueTy, TrueName) =
12825 CO->getTrueExpr()->getType(),
12826 CO->getTrueExpr());
12827 std::tie(FalseTy, FalseName) =
12829 CO->getFalseExpr()->getType(),
12830 CO->getFalseExpr());
12832 if (TrueTy == FalseTy)
12833 return std::make_pair(TrueTy, TrueName);
12834 else if (TrueTy.
isNull())
12835 return std::make_pair(FalseTy, FalseName);
12836 else if (FalseTy.
isNull())
12837 return std::make_pair(TrueTy, TrueName);
12840 return std::make_pair(
QualType(), StringRef());
12859 From = VecTy->getElementType();
12861 To = VecTy->getElementType();
12873 diag::warn_format_conversion_argument_type_mismatch_signedness, Loc)
12882 const char *StartSpecifier,
12883 unsigned SpecifierLen,
12885 using namespace analyze_format_string;
12886 using namespace analyze_printf;
12890 const analyze_printf::ArgType &AT = FS.getArgType(S.
Context, isObjCContext());
12895 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
12896 ExprTy = TET->getUnderlyingExpr()->getType();
12908 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
12911 getSpecifierRange(StartSpecifier, SpecifierLen);
12913 llvm::raw_svector_ostream os(FSString);
12915 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
12921 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
12922 ArgType::MatchKind Match = AT.matchesType(S.
Context, ExprTy);
12923 ArgType::MatchKind OrigMatch = Match;
12926 if (Match == ArgType::Match)
12930 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
12939 E = ICE->getSubExpr();
12948 ImplicitMatch = AT.matchesType(S.
Context, ExprTy);
12949 if (OrigMatch == ArgType::NoMatchSignedness &&
12950 ImplicitMatch != ArgType::NoMatchSignedness)
12957 if (ImplicitMatch == ArgType::Match)
12968 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
12975 if (Match == ArgType::MatchPromotion)
12976 Match = ArgType::NoMatch;
12979 if (Match == ArgType::MatchPromotion) {
12983 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
12984 ImplicitMatch != ArgType::NoMatchTypeConfusion)
12986 Match = ArgType::NoMatch;
12988 if (ImplicitMatch == ArgType::NoMatchPedantic ||
12989 ImplicitMatch == ArgType::NoMatchTypeConfusion)
12990 Match = ImplicitMatch;
12991 assert(Match != ArgType::MatchPromotion);
12994 bool IsEnum =
false;
12995 bool IsScopedEnum =
false;
12998 IntendedTy = EnumTy->getDecl()->getIntegerType();
12999 if (EnumTy->isUnscopedEnumerationType()) {
13000 ExprTy = IntendedTy;
13005 IsScopedEnum =
true;
13012 if (isObjCContext() &&
13013 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
13033 if (TD->getUnderlyingType() == IntendedTy)
13041 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
13049 if (!IsScopedEnum &&
13050 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
13051 (AT.isSizeT() || AT.isPtrdiffT()) &&
13052 AT.matchesType(S.
Context, CastTy))
13053 Match = ArgType::NoMatchPedantic;
13054 IntendedTy = CastTy;
13055 ShouldNotPrintDirectly =
true;
13060 PrintfSpecifier fixedFS = FS;
13067 llvm::raw_svector_ostream os(buf);
13068 fixedFS.toString(os);
13070 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
13072 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
13075 case ArgType::Match:
13076 case ArgType::MatchPromotion:
13077 case ArgType::NoMatchPromotionTypeConfusion:
13078 case ArgType::NoMatchSignedness:
13079 llvm_unreachable(
"expected non-matching");
13080 case ArgType::NoMatchPedantic:
13081 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
13083 case ArgType::NoMatchTypeConfusion:
13084 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
13086 case ArgType::NoMatch:
13087 Diag = diag::warn_format_conversion_argument_type_mismatch;
13094 << AT.getRepresentativeTypeName(S.
Context)
13108 llvm::raw_svector_ostream CastFix(CastBuf);
13109 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
13111 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
13114 ArgType::MatchKind IntendedMatch = AT.matchesType(S.
Context, IntendedTy);
13117 if ((IntendedMatch != ArgType::Match) || ShouldNotPrintDirectly)
13120 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
13122 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
13144 if (ShouldNotPrintDirectly && !IsScopedEnum) {
13150 Name = TypedefTy->getDecl()->getName();
13153 unsigned Diag = Match == ArgType::NoMatchPedantic
13154 ? diag::warn_format_argument_needs_cast_pedantic
13155 : diag::warn_format_argument_needs_cast;
13156 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
13167 ? diag::warn_format_conversion_argument_type_mismatch_pedantic
13168 : diag::warn_format_conversion_argument_type_mismatch;
13170 EmitFormatDiagnostic(
13182 bool EmitTypeMismatch =
false;
13188 case ArgType::Match:
13189 case ArgType::MatchPromotion:
13190 case ArgType::NoMatchPromotionTypeConfusion:
13191 case ArgType::NoMatchSignedness:
13192 llvm_unreachable(
"expected non-matching");
13193 case ArgType::NoMatchPedantic:
13194 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
13196 case ArgType::NoMatchTypeConfusion:
13197 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
13199 case ArgType::NoMatch:
13200 Diag = diag::warn_format_conversion_argument_type_mismatch;
13204 EmitFormatDiagnostic(
13213 EmitTypeMismatch =
true;
13215 EmitFormatDiagnostic(
13216 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
13217 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
13218 << AT.getRepresentativeTypeName(S.
Context) << CSR
13221 checkForCStrMembers(AT, E);
13227 EmitTypeMismatch =
true;
13229 EmitFormatDiagnostic(
13230 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
13231 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
13232 << AT.getRepresentativeTypeName(S.
Context) << CSR
13239 << isa<InitListExpr>(E) << ExprTy << CallType
13244 if (EmitTypeMismatch) {
13250 EmitFormatDiagnostic(
13251 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
13252 << AT.getRepresentativeTypeName(S.
Context) << ExprTy <<
false
13257 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
13258 "format string specifier index out of range");
13259 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
13269 class CheckScanfHandler :
public CheckFormatHandler {
13271 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
13273 unsigned firstDataArg,
unsigned numDataArgs,
13277 llvm::SmallBitVector &CheckedVarArgs,
13278 UncoveredArgHandler &UncoveredArg)
13279 : CheckFormatHandler(
s, fexpr, origFormatExpr,
type, firstDataArg,
13280 numDataArgs, beg, APK, Args, formatIdx,
13281 inFunctionCall, CallType, CheckedVarArgs,
13285 const char *startSpecifier,
13286 unsigned specifierLen)
override;
13288 bool HandleInvalidScanfConversionSpecifier(
13290 const char *startSpecifier,
13291 unsigned specifierLen)
override;
13293 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
13298 void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
13300 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
13301 getLocationOfByte(end),
true,
13302 getSpecifierRange(start, end - start));
13305 bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
13307 const char *startSpecifier,
13308 unsigned specifierLen) {
13310 FS.getConversionSpecifier();
13312 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
13314 startSpecifier, specifierLen,
13318 bool CheckScanfHandler::HandleScanfSpecifier(
13320 const char *startSpecifier,
13321 unsigned specifierLen) {
13322 using namespace analyze_scanf;
13323 using namespace analyze_format_string;
13325 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
13329 if (FS.consumesDataArgument()) {
13331 atFirstArg =
false;
13332 usesPositionalArgs = FS.usesPositionalArg();
13334 else if (usesPositionalArgs != FS.usesPositionalArg()) {
13335 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
13336 startSpecifier, specifierLen);
13342 const OptionalAmount &Amt = FS.getFieldWidth();
13343 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
13344 if (Amt.getConstantAmount() == 0) {
13346 Amt.getConstantLength());
13347 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
13348 getLocationOfByte(Amt.getStart()),
13354 if (!FS.consumesDataArgument()) {
13361 unsigned argIndex = FS.getArgIndex();
13362 if (argIndex < NumDataArgs) {
13366 CoveredArgs.set(argIndex);
13372 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
13373 diag::warn_format_nonsensical_length);
13374 else if (!FS.hasStandardLengthModifier())
13375 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
13376 else if (!FS.hasStandardLengthConversionCombination())
13377 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
13378 diag::warn_format_non_standard_conversion_spec);
13380 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
13381 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
13387 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
13391 const Expr *Ex = getDataArg(argIndex);
13408 ScanfSpecifier fixedFS = FS;
13413 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
13414 : diag::warn_format_conversion_argument_type_mismatch;
13419 llvm::raw_svector_ostream os(buf);
13420 fixedFS.toString(os);
13422 EmitFormatDiagnostic(
13427 getSpecifierRange(startSpecifier, specifierLen),
13429 getSpecifierRange(startSpecifier, specifierLen), os.str()));
13436 getSpecifierRange(startSpecifier, specifierLen));
13443 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
13447 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
13448 bool IgnoreStringsWithoutSpecifiers) {
13450 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
13451 CheckFormatHandler::EmitFormatDiagnostic(
13452 S, inFunctionCall, Args[format_idx],
13453 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
13459 StringRef StrRef = FExpr->getString();
13460 const char *Str = StrRef.data();
13464 assert(
T &&
"String literal not of constant array type!");
13465 size_t TypeSize =
T->getZExtSize();
13466 size_t StrLen =
std::min(
std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13467 const unsigned numDataArgs = Args.size() - firstDataArg;
13469 if (IgnoreStringsWithoutSpecifiers &&
13476 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
13477 CheckFormatHandler::EmitFormatDiagnostic(
13478 S, inFunctionCall, Args[format_idx],
13479 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
13480 FExpr->getBeginLoc(),
13486 if (StrLen == 0 && numDataArgs > 0) {
13487 CheckFormatHandler::EmitFormatDiagnostic(
13488 S, inFunctionCall, Args[format_idx],
13489 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
13497 CheckPrintfHandler H(
13498 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
13500 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
13506 H.DoneProcessing();
13508 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
13509 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
13510 CallType, CheckedVarArgs, UncoveredArg);
13514 H.DoneProcessing();
13521 const char *Str = StrRef.data();
13524 assert(
T &&
"String literal not of constant array type!");
13525 size_t TypeSize =
T->getZExtSize();
13526 size_t StrLen =
std::min(
std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
13537 switch (AbsFunction) {
13541 case Builtin::BI__builtin_abs:
13542 return Builtin::BI__builtin_labs;
13543 case Builtin::BI__builtin_labs:
13544 return Builtin::BI__builtin_llabs;
13545 case Builtin::BI__builtin_llabs:
13548 case Builtin::BI__builtin_fabsf:
13549 return Builtin::BI__builtin_fabs;
13550 case Builtin::BI__builtin_fabs:
13551 return Builtin::BI__builtin_fabsl;
13552 case Builtin::BI__builtin_fabsl:
13555 case Builtin::BI__builtin_cabsf:
13556 return Builtin::BI__builtin_cabs;
13557 case Builtin::BI__builtin_cabs:
13558 return Builtin::BI__builtin_cabsl;
13559 case Builtin::BI__builtin_cabsl:
13562 case Builtin::BIabs:
13563 return Builtin::BIlabs;
13564 case Builtin::BIlabs:
13565 return Builtin::BIllabs;
13566 case Builtin::BIllabs:
13569 case Builtin::BIfabsf:
13570 return Builtin::BIfabs;
13571 case Builtin::BIfabs:
13572 return Builtin::BIfabsl;
13573 case Builtin::BIfabsl:
13576 case Builtin::BIcabsf:
13577 return Builtin::BIcabs;
13578 case Builtin::BIcabs:
13579 return Builtin::BIcabsl;
13580 case Builtin::BIcabsl:
13587 unsigned AbsType) {
13609 unsigned AbsFunctionKind) {
13610 unsigned BestKind = 0;
13612 for (
unsigned Kind = AbsFunctionKind;
Kind != 0;
13618 else if (Context.
hasSameType(ParamType, ArgType)) {
13641 llvm_unreachable(
"Type not integer, floating, or complex");
13648 switch (ValueKind) {
13653 case Builtin::BI__builtin_fabsf:
13654 case Builtin::BI__builtin_fabs:
13655 case Builtin::BI__builtin_fabsl:
13656 case Builtin::BI__builtin_cabsf:
13657 case Builtin::BI__builtin_cabs:
13658 case Builtin::BI__builtin_cabsl:
13659 return Builtin::BI__builtin_abs;
13660 case Builtin::BIfabsf:
13661 case Builtin::BIfabs:
13662 case Builtin::BIfabsl:
13663 case Builtin::BIcabsf:
13664 case Builtin::BIcabs:
13665 case Builtin::BIcabsl:
13666 return Builtin::BIabs;
13672 case Builtin::BI__builtin_abs:
13673 case Builtin::BI__builtin_labs:
13674 case Builtin::BI__builtin_llabs:
13675 case Builtin::BI__builtin_cabsf:
13676 case Builtin::BI__builtin_cabs:
13677 case Builtin::BI__builtin_cabsl:
13678 return Builtin::BI__builtin_fabsf;
13679 case Builtin::BIabs:
13680 case Builtin::BIlabs:
13681 case Builtin::BIllabs:
13682 case Builtin::BIcabsf:
13683 case Builtin::BIcabs:
13684 case Builtin::BIcabsl:
13685 return Builtin::BIfabsf;
13691 case Builtin::BI__builtin_abs:
13692 case Builtin::BI__builtin_labs:
13693 case Builtin::BI__builtin_llabs:
13694 case Builtin::BI__builtin_fabsf:
13695 case Builtin::BI__builtin_fabs:
13696 case Builtin::BI__builtin_fabsl:
13697 return Builtin::BI__builtin_cabsf;
13698 case Builtin::BIabs:
13699 case Builtin::BIlabs:
13700 case Builtin::BIllabs:
13701 case Builtin::BIfabsf:
13702 case Builtin::BIfabs:
13703 case Builtin::BIfabsl:
13704 return Builtin::BIcabsf;
13707 llvm_unreachable(
"Unable to convert function");
13718 case Builtin::BI__builtin_abs:
13719 case Builtin::BI__builtin_fabs:
13720 case Builtin::BI__builtin_fabsf:
13721 case Builtin::BI__builtin_fabsl:
13722 case Builtin::BI__builtin_labs:
13723 case Builtin::BI__builtin_llabs:
13724 case Builtin::BI__builtin_cabs:
13725 case Builtin::BI__builtin_cabsf:
13726 case Builtin::BI__builtin_cabsl:
13727 case Builtin::BIabs:
13728 case Builtin::BIlabs:
13729 case Builtin::BIllabs:
13730 case Builtin::BIfabs:
13731 case Builtin::BIfabsf:
13732 case Builtin::BIfabsl:
13733 case Builtin::BIcabs:
13734 case Builtin::BIcabsf:
13735 case Builtin::BIcabsl:
13738 llvm_unreachable(
"Unknown Builtin type");
13744 unsigned AbsKind,
QualType ArgType) {
13745 bool EmitHeaderHint =
true;
13746 const char *HeaderName =
nullptr;
13747 StringRef FunctionName;
13749 FunctionName =
"std::abs";
13751 HeaderName =
"cstdlib";
13753 HeaderName =
"cmath";
13755 llvm_unreachable(
"Invalid Type");
13764 for (
const auto *I : R) {
13767 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
13769 FDecl = dyn_cast<FunctionDecl>(I);
13784 EmitHeaderHint =
false;
13802 EmitHeaderHint =
false;
13806 }
else if (!R.
empty()) {
13812 S.
Diag(Loc, diag::note_replace_abs_function)
13818 if (!EmitHeaderHint)
13821 S.
Diag(Loc, diag::note_include_header_or_declare) << HeaderName
13825 template <std::
size_t StrLen>
13827 const char (&Str)[StrLen]) {
13838 void Sema::CheckInfNaNFunction(
const CallExpr *Call,
13840 FPOptions FPO =
Call->getFPFeaturesInEffect(getLangOpts());
13842 (
Call->getBuiltinCallee() == Builtin::BI__builtin_nanf)) &&
13843 FPO.getNoHonorNaNs())
13844 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13845 << 1 << 0 <<
Call->getSourceRange();
13849 FPO.getNoHonorInfs())
13850 Diag(
Call->getBeginLoc(), diag::warn_fp_nan_inf_when_disabled)
13851 << 0 << 0 <<
Call->getSourceRange();
13855 void Sema::CheckAbsoluteValueFunction(
const CallExpr *Call,
13857 if (
Call->getNumArgs() != 1)
13862 if (AbsKind == 0 && !IsStdAbs)
13865 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
13871 StringRef FunctionName =
13873 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
13874 Diag(
Call->getExprLoc(), diag::note_remove_abs)
13883 unsigned DiagType = 0;
13889 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
13903 if (ArgValueKind == ParamValueKind) {
13908 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
13909 << FDecl << ArgType << ParamType;
13911 if (NewAbsKind == 0)
13915 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13924 if (NewAbsKind == 0)
13927 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
13928 << FDecl << ParamValueKind << ArgValueKind;
13931 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
13935 void Sema::CheckMaxUnsignedZero(
const CallExpr *Call,
13937 if (!Call || !FDecl)
return;
13940 if (inTemplateInstantiation())
return;
13941 if (
Call->getExprLoc().isMacroID())
return;
13944 if (
Call->getNumArgs() != 2)
return;
13947 if (!ArgList)
return;
13948 if (ArgList->size() != 1)
return;
13951 const auto& TA = ArgList->get(0);
13957 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
13958 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
13959 if (!MTE)
return false;
13960 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
13961 if (!Num)
return false;
13962 if (Num->getValue() != 0)
return false;
13966 const Expr *FirstArg =
Call->getArg(0);
13967 const Expr *SecondArg =
Call->getArg(1);
13968 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
13969 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
13972 if (IsFirstArgZero == IsSecondArgZero)
return;
13977 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
13979 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
13980 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
13984 if (IsFirstArgZero) {
13992 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
14012 if (!Size->isComparisonOp() && !Size->isLogicalOp())
14016 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
14017 << SizeRange << FnName;
14018 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
14023 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
14034 bool &IsContained) {
14037 IsContained =
false;
14050 for (
auto *FD : RD->
fields()) {
14054 IsContained =
true;
14055 return ContainedRD;
14063 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
14064 if (Unary->getKind() == UETT_SizeOf)
14073 if (!
SizeOf->isArgumentType())
14074 return SizeOf->getArgumentExpr()->IgnoreParenImpCasts();
14081 return SizeOf->getTypeOfArgument();
14087 struct SearchNonTrivialToInitializeField
14092 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
14096 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
14097 asDerived().visitArray(PDIK, AT, SL);
14101 Super::visitWithKind(PDIK, FT, SL);
14116 visit(getContext().getBaseElementType(AT), SL);
14121 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
14130 struct SearchNonTrivialToCopyField
14134 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
14138 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
14139 asDerived().visitArray(PCK, AT, SL);
14143 Super::visitWithKind(PCK, FT, SL);
14158 visit(getContext().getBaseElementType(AT), SL);
14166 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
14181 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
14182 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
14206 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
14208 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
14209 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
14215 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
14218 const Expr *SizeArg =
14219 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
14221 auto isLiteralZero = [](
const Expr *E) {
14222 return (isa<IntegerLiteral>(E) &&
14223 cast<IntegerLiteral>(E)->getValue() == 0) ||
14224 (isa<CharacterLiteral>(E) &&
14225 cast<CharacterLiteral>(E)->getValue() == 0);
14231 if (isLiteralZero(SizeArg) &&
14238 if (BId == Builtin::BIbzero ||
14241 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
14242 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
14243 }
else if (!isLiteralZero(Call->getArg(1)->IgnoreImpCasts())) {
14244 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
14245 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
14253 if (BId == Builtin::BImemset &&
14257 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
14258 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
14270 void Sema::CheckMemaccessArguments(
const CallExpr *Call,
14277 unsigned ExpectedNumArgs =
14278 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
14279 if (
Call->getNumArgs() < ExpectedNumArgs)
14282 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
14283 BId == Builtin::BIstrndup ? 1 : 2);
14285 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
14286 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
14289 Call->getBeginLoc(),
Call->getRParenLoc()))
14298 llvm::FoldingSetNodeID SizeOfArgID;
14303 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
14307 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
14308 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
14326 !Diags.isIgnored(diag::warn_sizeof_pointer_expr_memaccess,
14330 if (SizeOfArgID == llvm::FoldingSetNodeID())
14331 SizeOfArg->
Profile(SizeOfArgID, Context,
true);
14332 llvm::FoldingSetNodeID DestID;
14333 Dest->
Profile(DestID, Context,
true);
14334 if (DestID == SizeOfArgID) {
14337 unsigned ActionIdx = 0;
14338 StringRef ReadableName = FnName->
getName();
14340 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
14341 if (UnaryOp->getOpcode() == UO_AddrOf)
14355 if (
SM.isMacroArgExpansion(SL)) {
14357 SL =
SM.getSpellingLoc(SL);
14364 DiagRuntimeBehavior(SL, SizeOfArg,
14365 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
14371 DiagRuntimeBehavior(SL, SizeOfArg,
14372 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
14386 DiagRuntimeBehavior(LenExpr->
getExprLoc(), Dest,
14387 PDiag(diag::warn_sizeof_pointer_type_memaccess)
14388 << FnName << SizeOfArgTy << ArgIdx
14395 PointeeTy = DestTy;
14406 unsigned OperationType = 0;
14407 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
14410 if (ArgIdx != 0 || IsCmp) {
14411 if (BId == Builtin::BImemcpy)
14413 else if(BId == Builtin::BImemmove)
14419 DiagRuntimeBehavior(Dest->
getExprLoc(), Dest,
14420 PDiag(diag::warn_dyn_class_memaccess)
14421 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
14422 << IsContained << ContainedRD << OperationType
14423 <<
Call->getCallee()->getSourceRange());
14425 BId != Builtin::BImemset)
14426 DiagRuntimeBehavior(
14428 PDiag(diag::warn_arc_object_memaccess)
14429 << ArgIdx << FnName << PointeeTy
14430 <<
Call->getCallee()->getSourceRange());
14432 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
14433 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
14434 DiagRuntimeBehavior(Dest->
getExprLoc(), Dest,
14435 PDiag(diag::warn_cstruct_memaccess)
14436 << ArgIdx << FnName << PointeeTy << 0);
14437 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
14438 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
14439 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
14440 DiagRuntimeBehavior(Dest->
getExprLoc(), Dest,
14441 PDiag(diag::warn_cstruct_memaccess)
14442 << ArgIdx << FnName << PointeeTy << 1);
14443 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
14450 DiagRuntimeBehavior(
14452 PDiag(diag::note_bad_memaccess_silence)
14472 if (isa<IntegerLiteral>(RHS))
14474 else if (isa<IntegerLiteral>(LHS))
14488 if (CAT->getZExtSize() <= 1)
14498 void Sema::CheckStrlcpycatArguments(
const CallExpr *Call,
14502 unsigned NumArgs =
Call->getNumArgs();
14503 if ((NumArgs != 3) && (NumArgs != 4))
14508 const Expr *CompareWithSrc =
nullptr;
14511 Call->getBeginLoc(),
Call->getRParenLoc()))
14516 CompareWithSrc = Ex;
14519 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
14520 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
14521 SizeCall->getNumArgs() == 1)
14526 if (!CompareWithSrc)
14533 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
14537 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
14538 if (!CompareWithSrcDRE ||
14542 const Expr *OriginalSizeArg =
Call->getArg(2);
14543 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
14550 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
14555 llvm::raw_svector_ostream OS(sizeString);
14557 DstArg->
printPretty(OS,
nullptr, getPrintingPolicy());
14560 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
14567 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
14568 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
14569 return D1->getDecl() == D2->getDecl();
14574 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
14578 return CE->getArg(0)->IgnoreParenCasts();
14586 void Sema::CheckStrncatArguments(
const CallExpr *CE,
14601 unsigned PatternType = 0;
14609 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
14610 if (BE->getOpcode() == BO_Sub) {
14623 if (PatternType == 0)
14632 if (
SM.isMacroArgExpansion(SL)) {
14633 SL =
SM.getSpellingLoc(SL);
14642 if (!isKnownSizeArray) {
14643 if (PatternType == 1)
14644 Diag(SL, diag::warn_strncat_wrong_size) << SR;
14646 Diag(SL, diag::warn_strncat_src_size) << SR;
14650 if (PatternType == 1)
14651 Diag(SL, diag::warn_strncat_large_size) << SR;
14653 Diag(SL, diag::warn_strncat_src_size) << SR;
14656 llvm::raw_svector_ostream OS(sizeString);
14658 DstArg->
printPretty(OS,
nullptr, getPrintingPolicy());
14661 DstArg->
printPretty(OS,
nullptr, getPrintingPolicy());
14664 Diag(SL, diag::note_strncat_wrong_size)
14669 void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
14671 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
14673 << CalleeName << 0 << cast<NamedDecl>(D);
14678 void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
14680 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
14681 const Decl *D = Lvalue->getDecl();
14682 if (isa<DeclaratorDecl>(D))
14683 if (!dyn_cast<DeclaratorDecl>(D)->getType()->isReferenceType())
14684 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
14687 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
14688 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
14689 Lvalue->getMemberDecl());
14692 void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
14694 const auto *Lambda = dyn_cast<LambdaExpr>(
14699 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
14700 << CalleeName << 2 ;
14703 void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
14705 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
14706 if (Var ==
nullptr)
14710 << CalleeName << 0 << Var;
14713 void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
14716 llvm::raw_svector_ostream OS(SizeString);
14719 if (
Kind == clang::CK_BitCast &&
14720 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
14722 if (
Kind == clang::CK_IntegralToPointer &&
14723 !isa<IntegerLiteral>(
14724 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
14727 switch (
Cast->getCastKind()) {
14728 case clang::CK_BitCast:
14729 case clang::CK_IntegralToPointer:
14730 case clang::CK_FunctionToPointerDecay:
14739 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
14740 << CalleeName << 0 << OS.str();
14745 void Sema::CheckFreeArguments(
const CallExpr *E) {
14746 const std::string CalleeName =
14747 cast<FunctionDecl>(E->
getCalleeDecl())->getQualifiedNameAsString();
14751 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
14753 case UnaryOperator::Opcode::UO_AddrOf:
14754 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
14755 case UnaryOperator::Opcode::UO_Plus:
14756 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
14761 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
14763 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
14765 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
14766 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
14767 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
14771 if (isa<BlockExpr>(Arg)) {
14773 << CalleeName << 1 ;
14778 if (
const auto *
Cast = dyn_cast<CastExpr>(E->
getArg(0)))
14779 return CheckFreeArgumentsCast(*
this, CalleeName,
Cast);
14783 Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
14789 if (((Attrs && hasSpecificAttr<ReturnsNonNullAttr>(*Attrs)) ||
14792 Diag(ReturnLoc, diag::warn_null_ret)
14802 if (Op == OO_New || Op == OO_Array_New) {
14807 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
14808 << FD << getLangOpts().CPlusPlus11;
14813 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
14819 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
14832 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
14833 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
14835 return FPLiteral && FPCast;
14838 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
14846 llvm::APFloat::rmNearestTiesToEven, &Lossy);
14850 Diag(Loc, diag::warn_float_compare_literal)
14864 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
14865 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
14866 if (DRL->getDecl() == DRR->getDecl())
14874 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
14875 if (FLL->isExact())
14878 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
14879 if (FLR->isExact())
14883 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
14884 if (CL->getBuiltinCallee())
14887 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
14888 if (CR->getBuiltinCallee())
14892 Diag(Loc, diag::warn_floatingpoint_eq)
14913 IntRange(
unsigned Width,
bool NonNegative)
14914 : Width(Width), NonNegative(NonNegative) {}
14917 unsigned valueBits()
const {
14918 return NonNegative ? Width : Width - 1;
14922 static IntRange forBoolType() {
14923 return IntRange(1,
true);
14928 return forValueOfCanonicalType(C,
14933 static IntRange forValueOfCanonicalType(
ASTContext &C,
const Type *
T) {
14936 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14937 T = VT->getElementType().getTypePtr();
14939 T = CT->getElementType().getTypePtr();
14940 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14941 T = AT->getValueType().getTypePtr();
14943 if (!
C.getLangOpts().CPlusPlus) {
14945 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14946 T = ET->getDecl()->getIntegerType().getDesugaredType(C).getTypePtr();
14947 }
else if (
const EnumType *ET = dyn_cast<EnumType>(
T)) {
14952 if (
Enum->isFixed()) {
14953 return IntRange(
C.getIntWidth(
QualType(
T, 0)),
14957 unsigned NumPositive =
Enum->getNumPositiveBits();
14958 unsigned NumNegative =
Enum->getNumNegativeBits();
14960 if (NumNegative == 0)
14961 return IntRange(NumPositive,
true);
14963 return IntRange(
std::max(NumPositive + 1, NumNegative),
14967 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14968 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
14981 static IntRange forTargetOfCanonicalType(
ASTContext &C,
const Type *
T) {
14984 if (
const VectorType *VT = dyn_cast<VectorType>(
T))
14985 T = VT->getElementType().getTypePtr();
14987 T = CT->getElementType().getTypePtr();
14988 if (
const AtomicType *AT = dyn_cast<AtomicType>(
T))
14989 T = AT->getValueType().getTypePtr();
14990 if (
const EnumType *ET = dyn_cast<EnumType>(
T))
14991 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
14993 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
14994 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
15003 static IntRange join(IntRange L, IntRange R) {
15004 bool Unsigned = L.NonNegative && R.NonNegative;
15005 return IntRange(
std::max(L.valueBits(), R.valueBits()) + !Unsigned,
15006 L.NonNegative && R.NonNegative);
15010 static IntRange bit_and(IntRange L, IntRange R) {
15011 unsigned Bits =
std::max(L.Width, R.Width);
15012 bool NonNegative =
false;
15013 if (L.NonNegative) {
15015 NonNegative =
true;
15017 if (R.NonNegative) {
15019 NonNegative =
true;
15021 return IntRange(Bits, NonNegative);
15025 static IntRange sum(IntRange L, IntRange R) {
15026 bool Unsigned = L.NonNegative && R.NonNegative;
15027 return IntRange(
std::max(L.valueBits(), R.valueBits()) + 1 + !Unsigned,
15032 static IntRange difference(IntRange L, IntRange R) {
15036 bool CanWiden = !L.NonNegative || !R.NonNegative;
15037 bool Unsigned = L.NonNegative && R.Width == 0;
15038 return IntRange(
std::max(L.valueBits(), R.valueBits()) + CanWiden +
15044 static IntRange product(IntRange L, IntRange R) {
15048 bool CanWiden = !L.NonNegative && !R.NonNegative;
15049 bool Unsigned = L.NonNegative && R.NonNegative;
15050 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !Unsigned,
15055 static IntRange rem(IntRange L, IntRange R) {
15059 return IntRange(
std::min(L.valueBits(), R.valueBits()) + !Unsigned,
15067 unsigned MaxWidth) {
15068 if (value.isSigned() && value.isNegative())
15069 return IntRange(value.getSignificantBits(),
false);
15071 if (value.getBitWidth() > MaxWidth)
15072 value = value.trunc(MaxWidth);
15076 return IntRange(value.getActiveBits(),
true);
15080 unsigned MaxWidth) {
15081 if (result.
isInt())
15088 R = IntRange::join(R, El);
15096 return IntRange::join(R, I);
15111 Ty = AtomicRHS->getValueType();
15124 bool InConstantContext,
bool Approximate) {
15135 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
15136 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
15137 return GetExprRange(C, CE->getSubExpr(), MaxWidth, InConstantContext,
15140 IntRange OutputTypeRange = IntRange::forValueOfType(C,
GetExprType(CE));
15142 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
15143 CE->getCastKind() == CK_BooleanToSignedIntegral;
15146 if (!isIntegerCast)
15147 return OutputTypeRange;
15150 std::min(MaxWidth, OutputTypeRange.Width),
15151 InConstantContext, Approximate);
15154 if (SubRange.Width >= OutputTypeRange.Width)
15155 return OutputTypeRange;
15159 return IntRange(SubRange.Width,
15160 SubRange.NonNegative || OutputTypeRange.NonNegative);
15163 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
15166 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C))
15168 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
15169 MaxWidth, InConstantContext, Approximate);
15174 Expr *E = CO->getTrueExpr();
15176 ? IntRange{0,
true}
15177 :
GetExprRange(C, E, MaxWidth, InConstantContext, Approximate);
15178 E = CO->getFalseExpr();
15180 ? IntRange{0,
true}
15181 :
GetExprRange(C, E, MaxWidth, InConstantContext, Approximate);
15182 return IntRange::join(L, R);
15185 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
15186 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
15188 switch (BO->getOpcode()) {
15190 llvm_unreachable(
"builtin <=> should have class type");
15201 return IntRange::forBoolType();
15213 return IntRange::forValueOfType(C,
GetExprType(E));
15219 return GetExprRange(C, BO->getRHS(), MaxWidth, InConstantContext,
15225 return IntRange::forValueOfType(C,
GetExprType(E));
15230 Combine = IntRange::bit_and;
15238 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
15239 if (I->getValue() == 1) {
15240 IntRange R = IntRange::forValueOfType(C,
GetExprType(E));
15241 return IntRange(R.Width,
true);
15247 return IntRange::forValueOfType(C,
GetExprType(E));
15251 case BO_ShrAssign: {
15252 IntRange L =
GetExprRange(C, BO->getLHS(), MaxWidth, InConstantContext,
15257 if (std::optional<llvm::APSInt> shift =
15258 BO->getRHS()->getIntegerConstantExpr(C)) {
15259 if (shift->isNonNegative()) {
15260 if (shift->uge(L.Width))
15261 L.Width = (L.NonNegative ? 0 : 1);
15263 L.Width -= shift->getZExtValue();
15272 return GetExprRange(C, BO->getRHS(), MaxWidth, InConstantContext,
15277 Combine = IntRange::sum;
15281 if (BO->getLHS()->getType()->isPointerType())
15282 return IntRange::forValueOfType(C,
GetExprType(E));
15284 Combine = IntRange::difference;
15289 Combine = IntRange::product;
15296 unsigned opWidth = C.getIntWidth(
GetExprType(E));
15297 IntRange L =
GetExprRange(C, BO->getLHS(), opWidth, InConstantContext,
15301 if (std::optional<llvm::APSInt> divisor =
15302 BO->getRHS()->getIntegerConstantExpr(C)) {
15303 unsigned log2 = divisor->logBase2();
15304 if (
log2 >= L.Width)
15305 L.Width = (L.NonNegative ? 0 : 1);
15314 IntRange R =
GetExprRange(C, BO->getRHS(), opWidth, InConstantContext,
15316 return IntRange(L.Width, L.NonNegative && R.NonNegative);
15320 Combine = IntRange::rem;
15332 unsigned opWidth = C.getIntWidth(
T);
15334 GetExprRange(C, BO->getLHS(), opWidth, InConstantContext, Approximate);
15336 GetExprRange(C, BO->getRHS(), opWidth, InConstantContext, Approximate);
15337 IntRange C = Combine(L, R);
15339 C.Width =
std::min(C.Width, MaxWidth);
15343 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
15344 switch (UO->getOpcode()) {
15347 return IntRange::forBoolType();
15352 return IntRange::forValueOfType(C,
GetExprType(E));
15355 return GetExprRange(C, UO->getSubExpr(), MaxWidth, InConstantContext,
15360 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
15361 return GetExprRange(C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
15365 return IntRange(BitField->getBitWidthValue(C),
15366 BitField->getType()->isUnsignedIntegerOrEnumerationType());
15368 return IntRange::forValueOfType(C,
GetExprType(E));
15372 bool InConstantContext,
bool Approximate) {
15381 const llvm::fltSemantics &Src,
15382 const llvm::fltSemantics &Tgt) {
15386 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
15387 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
15389 return truncated.bitwiseIsEqual(value);
15398 const llvm::fltSemantics &Src,
15399 const llvm::fltSemantics &Tgt) {
15416 bool IsListInit =
false);
15422 if (isa<EnumConstantDecl>(DR->getDecl()))
15432 return MacroName !=
"YES" && MacroName !=
"NO" &&
15433 MacroName !=
"true" && MacroName !=
"false";
15456 struct PromotedRange {
15462 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
15464 PromotedMin = PromotedMax =
llvm::APSInt(BitWidth, Unsigned);
15465 else if (R.Width >= BitWidth && !Unsigned) {
15469 PromotedMin = llvm::APSInt::getMinValue(BitWidth, Unsigned);
15470 PromotedMax = llvm::APSInt::getMaxValue(BitWidth, Unsigned);
15472 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
15473 .extOrTrunc(BitWidth);
15474 PromotedMin.setIsUnsigned(Unsigned);
15476 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
15477 .extOrTrunc(BitWidth);
15478 PromotedMax.setIsUnsigned(Unsigned);
15483 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
15493 InRangeFlag = 0x40,
15496 Min =
LE | InRangeFlag,
15498 Max =
GE | InRangeFlag,
15501 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
15506 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
15507 Value.isUnsigned() == PromotedMin.isUnsigned());
15508 if (!isContiguous()) {
15509 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
15510 if (
Value.isMinValue())
return Min;
15511 if (
Value.isMaxValue())
return Max;
15517 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
15518 case -1:
return Less;
15519 case 0:
return PromotedMin == PromotedMax ? OnlyValue :
Min;
15521 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
15523 case 0:
return Max;
15528 llvm_unreachable(
"impossible compare result");
15531 static std::optional<StringRef>
15533 if (Op == BO_Cmp) {
15535 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
15537 if (R &
EQ)
return StringRef(
"'std::strong_ordering::equal'");
15538 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
15539 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
15540 return std::nullopt;
15547 }
else if (Op == BO_NE) {
15551 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
15558 if (Op == BO_GE || Op == BO_LE)
15559 std::swap(TrueFlag, FalseFlag);
15562 return StringRef(
"true");
15564 return StringRef(
"false");
15565 return std::nullopt;
15573 if (ICE->getCastKind() != CK_IntegralCast &&
15574 ICE->getCastKind() != CK_NoOp)
15576 E = ICE->getSubExpr();
15585 enum ConstantValueKind {
15590 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
15591 return BL->getValue() ? ConstantValueKind::LiteralTrue
15592 : ConstantValueKind::LiteralFalse;
15593 return ConstantValueKind::Miscellaneous;
15599 bool RhsConstant) {
15624 OtherT = AT->getValueType();
15625 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
15629 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
15630 S.
NSAPIObj->isObjCBOOLType(OtherT) &&
15635 bool OtherIsBooleanDespiteType =
15637 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
15638 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
15642 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
15643 Value.isUnsigned());
15644 auto Cmp = OtherPromotedValueRange.compare(
Value);
15645 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
15651 bool TautologicalTypeCompare =
false;
15653 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
15654 Value.isUnsigned());
15655 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
15658 TautologicalTypeCompare =
true;
15666 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
15675 bool InRange = Cmp & PromotedRange::InRangeFlag;
15682 Other->getType()->isUnsignedIntegerOrEnumerationType())
15683 TautologicalTypeCompare =
true;
15688 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
15689 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
15693 llvm::raw_svector_ostream OS(PrettySourceValue);
15695 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
15696 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
15698 OS << (BL->getValue() ?
"YES" :
"NO");
15703 if (!TautologicalTypeCompare) {
15705 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
15711 if (IsObjCSignedCharBool) {
15713 S.
PDiag(diag::warn_tautological_compare_objc_bool)
15714 << OS.str() << *Result);
15726 : diag::warn_tautological_bool_compare)
15728 << OtherIsBooleanDespiteType << *Result
15735 ? diag::warn_unsigned_enum_always_true_comparison
15736 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
15737 : diag::warn_unsigned_always_true_comparison)
15738 : diag::warn_tautological_constant_compare;
15741 << RhsConstant << OtherT << E->
getOpcodeStr() << OS.str() << *Result
15775 std::optional<llvm::APSInt> RHSValue =
15777 std::optional<llvm::APSInt> LHSValue =
15781 if (RHSValue && LHSValue)
15785 if ((
bool)RHSValue ^ (
bool)LHSValue) {
15787 const bool RhsConstant = (
bool)RHSValue;
15788 Expr *Const = RhsConstant ? RHS : LHS;
15813 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
15815 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
15821 Expr *signedOperand, *unsignedOperand;
15824 "unsigned comparison between two signed integer expressions?");
15825 signedOperand = LHS;
15826 unsignedOperand = RHS;
15828 signedOperand = RHS;
15829 unsignedOperand = LHS;
15835 IntRange signedRange =
15845 if (signedRange.NonNegative)
15854 IntRange unsignedRange =
15860 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
15862 if (unsignedRange.Width < comparisonWidth)
15867 S.
PDiag(diag::warn_mixed_sign_comparison)
15895 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
15896 << BitfieldEnumDecl;
15903 Init->isValueDependent() ||
15904 Init->isTypeDependent())
15907 Expr *OriginalInit = Init->IgnoreParenImpCasts();
15930 unsigned DiagID = 0;
15931 if (SignedEnum && !SignedBitfield) {
15932 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
15933 }
else if (SignedBitfield && !SignedEnum &&
15935 DiagID = diag::warn_signed_bitfield_enum_conversion;
15939 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
15944 << SignedEnum << TypeRange;
15955 if (BitsNeeded > FieldWidth) {
15957 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
15969 unsigned OriginalWidth =
Value.getBitWidth();
15975 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
15976 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
15983 if (!
Value.isSigned() ||
Value.isNegative())
15984 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
15985 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
15986 OriginalWidth =
Value.getSignificantBits();
15988 if (OriginalWidth <= FieldWidth)
15996 TruncatedValue = TruncatedValue.extend(OriginalWidth);
15997 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
16001 std::string PrettyTrunc =
toString(TruncatedValue, 10);
16003 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
16004 ? diag::warn_impcast_single_bit_bitield_precision_constant
16005 : diag::warn_impcast_bitfield_precision_constant)
16006 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
16007 << Init->getSourceRange();
16039 bool pruneControlFlow =
false) {
16040 if (pruneControlFlow) {
16054 unsigned diag,
bool pruneControlFlow =
false) {
16064 Sema &S,
Expr *SourceExpr,
const Sema::SemaDiagnosticBuilder &Builder) {
16066 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
16067 Ignored = OVE->getSourceExpr();
16068 bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
16069 isa<BinaryOperator>(Ignored) ||
16070 isa<CXXOperatorCallExpr>(Ignored);
16087 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
16090 const bool IsLiteral =
16091 isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
16100 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
16105 diag::warn_impcast_float_integer, PruneWarnings);
16108 bool isExact =
false;
16112 llvm::APFloat::opStatus Result =
Value.convertToInteger(
16113 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
16121 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
16122 precision = (precision * 59 + 195) / 196;
16123 Value.toString(PrettySourceValue, precision);
16128 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
16129 << PrettySourceValue);
16132 if (Result == llvm::APFloat::opOK && isExact) {
16133 if (IsLiteral)
return;
16134 return DiagnoseImpCast(S, E,
T, CContext, diag::warn_impcast_float_integer,
16140 if (!IsBool && Result == llvm::APFloat::opInvalidOp)
16143 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
16144 : diag::warn_impcast_float_to_integer_out_of_range,
16147 unsigned DiagID = 0;
16150 DiagID = diag::warn_impcast_literal_float_to_integer;
16151 }
else if (IntegerValue == 0) {
16152 if (
Value.isZero()) {
16154 diag::warn_impcast_float_integer, PruneWarnings);
16157 DiagID = diag::warn_impcast_float_to_integer_zero;
16159 if (IntegerValue.isUnsigned()) {
16160 if (!IntegerValue.isMaxValue()) {
16162 diag::warn_impcast_float_integer, PruneWarnings);
16165 if (!IntegerValue.isMaxSignedValue() &&
16166 !IntegerValue.isMinSignedValue()) {
16168 diag::warn_impcast_float_integer, PruneWarnings);
16172 DiagID = diag::warn_impcast_float_to_integer;
16177 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
16179 IntegerValue.toString(PrettyTargetValue);
16181 if (PruneWarnings) {
16184 << E->
getType() <<
T.getUnqualifiedType()
16185 << PrettySourceValue << PrettyTargetValue
16189 << E->
getType() <<
T.getUnqualifiedType() << PrettySourceValue
16197 assert(isa<CompoundAssignOperator>(E) &&
16198 "Must be compound assignment operation");
16208 const auto *RBT = cast<CompoundAssignOperator>(E)
16209 ->getComputationResultType()
16216 if (ResultBT->isInteger())
16218 E->
getExprLoc(), diag::warn_impcast_float_integer);
16220 if (!ResultBT->isFloatingPoint())
16229 diag::warn_impcast_float_result_precision);
16234 if (!Range.Width)
return "0";
16237 ValueInRange.setIsSigned(!Range.NonNegative);
16238 ValueInRange = ValueInRange.trunc(Range.Width);
16239 return toString(ValueInRange, 10);
16243 if (!isa<ImplicitCastExpr>(Ex))
16248 const Type *Source =
16250 if (
Target->isDependentType())
16254 dyn_cast<BuiltinType>(ToBool ? Source :
Target);
16255 const Type *BoolCandidateType = ToBool ?
Target : Source;
16264 for (
unsigned i = 0; i < NumArgs; ++i) {
16269 bool IsSwapped = ((i > 0) &&
16271 IsSwapped |= ((i < (NumArgs - 1)) &&
16277 diag::warn_impcast_floating_point_to_bool);
16284 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
16289 if (isa<CallExpr>(E))
16294 bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
16296 if (!IsGNUNullExpr && !HasNullPtrType)
16313 if (IsGNUNullExpr && Loc.
isMacroID()) {
16316 if (MacroName ==
"NULL")
16324 S.
Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
16342 unsigned ElementKind) {
16344 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
16345 if (ICE->getCastKind() == CK_BitCast &&
16347 Element = ICE->getSubExpr();
16350 QualType ElementType = Element->getType();
16357 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
16358 << ElementType << ElementKind << TargetElementType
16359 << Element->getSourceRange();
16362 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
16364 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
16376 if (!TargetObjCPtr)
16379 if (TargetObjCPtr->isUnspecialized() ||
16380 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
16385 if (TypeArgs.size() != 1)
16388 QualType TargetElementType = TypeArgs[0];
16389 for (
unsigned I = 0, N = ArrayLiteral->
getNumElements(); I != N; ++I) {
16405 if (!TargetObjCPtr)
16408 if (TargetObjCPtr->isUnspecialized() ||
16409 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
16414 if (TypeArgs.size() != 2)
16417 QualType TargetKeyType = TypeArgs[0];
16418 QualType TargetObjectType = TypeArgs[1];
16419 for (
unsigned I = 0, N = DictionaryLiteral->
getNumElements(); I != N; ++I) {
16434 const char FirstLiteralCharacter =
16436 if (FirstLiteralCharacter ==
'0')
16443 const char FirstContextCharacter =
16445 if (FirstContextCharacter ==
'{')
16453 const auto *IL = dyn_cast<IntegerLiteral>(E);
16455 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
16456 if (UO->getOpcode() == UO_Minus)
16457 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
16468 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
16472 if (Opc == BO_Shl) {
16475 if (LHS && LHS->getValue() == 0)
16476 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
16478 RHS->getValue().isNonNegative() &&
16480 S.
Diag(ExprLoc, diag::warn_left_shift_always)
16481 << (Result.Val.getInt() != 0);
16483 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
16487 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
16492 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
16493 (RHS->getValue() == 0 || RHS->getValue() == 1))
16496 if (LHS->getValue() != 0 && RHS->getValue() != 0)
16497 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
16503 bool *ICContext =
nullptr,
16504 bool IsListInit =
false) {
16509 if (Source ==
Target)
return;
16510 if (
Target->isDependentType())
return;
16524 if (
Target->isSpecificBuiltinType(BuiltinType::Bool)) {
16525 if (isa<StringLiteral>(E))
16530 diag::warn_impcast_string_literal_to_bool);
16531 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
16532 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
16536 diag::warn_impcast_objective_c_literal_to_bool);
16552 if (Result.Val.getInt() != 1 && Result.Val.getInt() != 0) {
16555 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
16556 <<
toString(Result.Val.getInt(), 10));
16564 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
16566 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
16570 if (isa<VectorType>(Source)) {
16571 if (
Target->isSveVLSBuiltinType() &&
16578 if (
Target->isRVVVLSBuiltinType() &&
16585 if (!isa<VectorType>(
Target)) {
16603 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
16604 Target = cast<VectorType>(
Target)->getElementType().getTypePtr();
16606 if (
auto VecTy = dyn_cast<VectorType>(
Target))
16607 Target = VecTy->getElementType().getTypePtr();
16610 if (isa<ComplexType>(Source)) {
16611 if (!isa<ComplexType>(
Target)) {
16617 ? diag::err_impcast_complex_scalar
16618 : diag::warn_impcast_complex_scalar);
16621 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
16622 Target = cast<ComplexType>(
Target)->getElementType().getTypePtr();
16625 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
16671 diag::warn_imp_float_size_conversion);
16674 diag::warn_imp_float_size_conversion);
16685 if (S.
Diags.
isIgnored(diag::warn_impcast_float_precision, CC)) {
16694 else if (Order < 0) {
16704 if (TargetBT && TargetBT->
isInteger()) {
16719 if (
Target->isBooleanType() && isa<CallExpr>(E)) {
16723 CallExpr *CEx = cast<CallExpr>(E);
16727 if (isa<ImplicitCastExpr>(LastA) &&
16731 diag::warn_impcast_floating_point_to_bool);
16740 if (
Target->isUnsaturatedFixedPointType()) {
16744 llvm::APFixedPoint
Value = Result.Val.getFixedPoint();
16749 S.
PDiag(diag::warn_impcast_fixed_point_range)
16750 <<
Value.toString() <<
T
16756 }
else if (
Target->isIntegerType()) {
16761 llvm::APFixedPoint FXResult = Result.Val.getFixedPoint();
16766 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
16770 S.
PDiag(diag::warn_impcast_fixed_point_range)
16771 << FXResult.toString() <<
T
16778 }
else if (
Target->isUnsaturatedFixedPointType()) {
16786 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
16791 S.
PDiag(diag::warn_impcast_fixed_point_range)
16810 unsigned int SourcePrecision =
SourceRange.Width;
16814 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
16817 if (SourcePrecision > 0 && TargetPrecision > 0 &&
16818 SourcePrecision > TargetPrecision) {
16820 if (std::optional<llvm::APSInt> SourceInt =
16827 llvm::APFloat::opStatus ConversionStatus =
16828 TargetFloatValue.convertFromAPInt(
16830 llvm::APFloat::rmNearestTiesToEven);
16832 if (ConversionStatus != llvm::APFloat::opOK) {
16834 SourceInt->toString(PrettySourceValue, 10);
16836 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
16840 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
16841 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16847 diag::warn_impcast_integer_float_precision);
16856 if (
Target->isBooleanType())
16864 if (
Target->isSpecificBuiltinType(BuiltinType::Bool))
16871 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
16875 IntRange SourceTypeRange =
16876 IntRange::forTargetOfCanonicalType(S.
Context, Source);
16879 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context,
Target);
16881 if (LikelySourceRange.Width > TargetRange.Width) {
16888 Value = Result.Val.getInt();
16898 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16899 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16911 return DiagnoseImpCast(S, E,
T, CC, diag::warn_impcast_integer_precision);
16914 if (TargetRange.Width > SourceTypeRange.Width) {
16915 if (
auto *UO = dyn_cast<UnaryOperator>(E))
16916 if (UO->getOpcode() == UO_Minus)
16918 if (
Target->isUnsignedIntegerType())
16920 diag::warn_impcast_high_order_zero_bits);
16921 if (
Target->isSignedIntegerType())
16923 diag::warn_impcast_nonnegative_result);
16927 if (TargetRange.Width == LikelySourceRange.Width &&
16928 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16944 S.
PDiag(diag::warn_impcast_integer_precision_constant)
16945 << PrettySourceValue << PrettyTargetValue << E->
getType() <<
T
16954 if ((!isa<EnumType>(
Target) || !isa<EnumType>(Source)) &&
16955 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
16956 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
16957 LikelySourceRange.Width == TargetRange.Width))) {
16961 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
16967 unsigned DiagID = diag::warn_impcast_integer_sign;
16975 DiagID = diag::warn_impcast_integer_sign_conditional;
16990 if (SourceEnum->getDecl()->hasNameForLinkage() &&
16991 TargetEnum->getDecl()->hasNameForLinkage() &&
16992 SourceEnum != TargetEnum) {
16997 diag::warn_impcast_different_enum_types);
17011 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
17024 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
17025 TrueExpr = BCO->getCommon();
17027 bool Suspicious =
false;
17036 if (!Suspicious)
return;
17039 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
17046 Suspicious =
false;
17048 E->
getType(), CC, &Suspicious);
17051 E->
getType(), CC, &Suspicious);
17068 struct AnalyzeImplicitConversionsWorkItem {
17078 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
17080 Expr *OrigE = Item.E;
17089 bool IsListInit = Item.IsListInit ||
17090 (isa<InitListExpr>(OrigE) && S.
getLangOpts().CPlusPlus);
17095 Expr *SourceExpr = E;
17100 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
17101 if (
auto *Src = OVE->getSourceExpr())
17104 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
17105 if (UO->getOpcode() == UO_Not &&
17106 UO->getSubExpr()->isKnownToHaveBooleanValue())
17107 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
17111 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
17112 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
17113 BO->getLHS()->isKnownToHaveBooleanValue() &&
17114 BO->getRHS()->isKnownToHaveBooleanValue() &&
17115 BO->getLHS()->HasSideEffects(S.
Context) &&
17116 BO->getRHS()->HasSideEffects(S.
Context)) {
17127 if (SR.str() ==
"&" || SR.str() ==
"|") {
17129 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
17130 << (BO->getOpcode() == BO_And ?
"&" :
"|")
17133 BO->getOperatorLoc(),
17134 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
17135 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
17141 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
17147 if (
CallExpr *Call = dyn_cast<CallExpr>(SourceExpr))
17162 for (
auto *SE : POE->semantics())
17163 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
17164 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
17168 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
17172 WorkList.push_back({E, CC, IsListInit});
17178 if (BO->isComparisonOp())
17182 if (BO->getOpcode() == BO_Assign)
17185 if (BO->isAssignmentOp())
17193 if (isa<StmtExpr>(E))
return;
17196 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
17201 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
17203 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
17207 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
17208 if (ChildExpr == CSE->getOperand())
17214 if (IsLogicalAndOperator &&
17219 WorkList.push_back({ChildExpr, CC, IsListInit});
17224 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
17228 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
17233 if (
U->getOpcode() == UO_LNot) {
17235 }
else if (
U->getOpcode() != UO_AddrOf) {
17236 if (
U->getSubExpr()->getType()->isAtomicType())
17237 S.
Diag(
U->getSubExpr()->getBeginLoc(),
17238 diag::warn_atomic_implicit_seq_cst);
17249 WorkList.push_back({OrigE, CC, IsListInit});
17250 while (!WorkList.empty())
17260 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
17277 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
17280 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
17281 if (!M->getMemberDecl()->getType()->isReferenceType())
17283 }
else if (
const CallExpr *Call = dyn_cast<CallExpr>(E)) {
17284 if (!Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
17286 FD = Call->getDirectCallee();
17295 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
17309 if (
SM.isMacroBodyExpansion(Loc))
17311 Loc =
SM.getImmediateMacroCallerLoc(Loc);
17340 if (isa<CXXThisExpr>(E)) {
17341 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
17342 : diag::warn_this_bool_conversion;
17347 bool IsAddressOf =
false;
17349 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
17350 if (UO->getOpcode() != UO_AddrOf)
17352 IsAddressOf =
true;
17353 E = UO->getSubExpr();
17357 unsigned DiagID = IsCompare
17358 ? diag::warn_address_of_reference_null_compare
17359 : diag::warn_address_of_reference_bool_conversion;
17367 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
17368 bool IsParam = isa<NonNullAttr>(NonnullAttr);
17370 llvm::raw_string_ostream S(Str);
17372 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
17373 : diag::warn_cast_nonnull_to_bool;
17376 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
17381 if (
auto *Callee = Call->getDirectCallee()) {
17382 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
17383 ComplainAboutNonnullParamOrCall(A);
17391 if (!inTemplateInstantiation()) {
17392 if (
const auto *MCallExpr = dyn_cast<CXXMemberCallExpr>(E)) {
17393 if (
const auto *MRecordDecl = MCallExpr->getRecordDecl();
17394 MRecordDecl && MRecordDecl->isLambda()) {
17397 << MRecordDecl->getSourceRange() << Range << IsEqual;
17407 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
17408 D = M->getMemberDecl();
17416 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
17417 if (getCurFunction() &&
17418 !getCurFunction()->ModifiedNonNullParams.count(PV)) {
17419 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
17420 ComplainAboutNonnullParamOrCall(A);
17424 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
17428 auto ParamIter = llvm::find(FD->
parameters(), PV);
17434 ComplainAboutNonnullParamOrCall(
NonNull);
17439 if (ArgNo.getASTIndex() == ParamNo) {
17440 ComplainAboutNonnullParamOrCall(
NonNull);
17454 if (IsAddressOf && IsFunction) {
17459 if (!IsAddressOf && !IsFunction && !IsArray)
17464 llvm::raw_string_ostream S(Str);
17467 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
17468 : diag::warn_impcast_pointer_to_bool;
17475 DiagType = AddressOf;
17476 else if (IsFunction)
17477 DiagType = FunctionPointer;
17479 DiagType = ArrayPointer;
17481 llvm_unreachable(
"Could not determine diagnostic.");
17483 << Range << IsEqual;
17495 tryExprAsCall(*E, ReturnType, NonTemplateOverloads);
17496 if (ReturnType.
isNull())
17531 if (isUnevaluatedContext())
17541 CheckArrayAccess(E);
17555 void Sema::CheckForIntOverflow (
const Expr *E) {
17560 const Expr *OriginalE = Exprs.pop_back_val();
17563 if (isa<BinaryOperator, UnaryOperator>(E)) {
17568 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
17569 Exprs.append(InitList->inits().begin(), InitList->inits().end());
17570 else if (isa<ObjCBoxedExpr>(OriginalE))
17572 else if (
const auto *Call = dyn_cast<CallExpr>(E))
17573 Exprs.append(
Call->arg_begin(),
Call->arg_end());
17574 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
17575 Exprs.append(Message->arg_begin(), Message->arg_end());
17576 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
17577 Exprs.append(Construct->arg_begin(), Construct->arg_end());
17578 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
17579 Exprs.push_back(Temporary->getSubExpr());
17580 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
17581 Exprs.push_back(
Array->getIdx());
17582 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
17583 Exprs.push_back(Compound->getInitializer());
17584 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
17585 New && New->isArray()) {
17586 if (
auto ArraySize = New->getArraySize())
17587 Exprs.push_back(*ArraySize);
17589 }
while (!Exprs.empty());
17604 class SequenceTree {
17608 LLVM_PREFERRED_TYPE(
bool)
17609 unsigned Merged : 1;
17617 friend class SequenceTree;
17621 explicit Seq(
unsigned N) : Index(N) {}
17624 Seq() : Index(0) {}
17627 SequenceTree() { Values.push_back(
Value(0)); }
17628 Seq root()
const {
return Seq(0); }
17635 return Seq(Values.size() - 1);
17639 void merge(Seq S) {
17640 Values[S.Index].Merged =
true;
17646 bool isUnsequenced(Seq Cur, Seq Old) {
17647 unsigned C = representative(Cur.Index);
17648 unsigned Target = representative(Old.Index);
17652 C = Values[
C].Parent;
17659 unsigned representative(
unsigned K) {
17660 if (Values[K].Merged)
17662 return Values[K].Parent = representative(Values[K].
Parent);
17682 UK_ModAsSideEffect,
17684 UK_Count = UK_ModAsSideEffect + 1
17690 const Expr *UsageExpr =
nullptr;
17691 SequenceTree::Seq
Seq;
17697 Usage Uses[UK_Count];
17700 bool Diagnosed =
false;
17704 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
17712 UsageInfoMap UsageMap;
17715 SequenceTree::Seq Region;
17730 struct SequencedSubexpression {
17731 SequencedSubexpression(SequenceChecker &Self)
17732 : Self(Self), OldModAsSideEffect(Self.ModAsSideEffect) {
17733 Self.ModAsSideEffect = &ModAsSideEffect;
17736 ~SequencedSubexpression() {
17737 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
17741 UsageInfo &UI = Self.UsageMap[M.first];
17742 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
17743 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
17744 SideEffectUsage = M.second;
17746 Self.ModAsSideEffect = OldModAsSideEffect;
17749 SequenceChecker &Self;
17758 class EvaluationTracker {
17760 EvaluationTracker(SequenceChecker &Self)
17761 : Self(Self), Prev(Self.EvalTracker) {
17762 Self.EvalTracker =
this;
17765 ~EvaluationTracker() {
17766 Self.EvalTracker = Prev;
17768 Prev->EvalOK &= EvalOK;
17771 bool evaluate(
const Expr *E,
bool &Result) {
17775 Result, Self.SemaRef.Context,
17776 Self.SemaRef.isConstantEvaluatedContext());
17781 SequenceChecker &Self;
17782 EvaluationTracker *Prev;
17783 bool EvalOK =
true;
17784 } *EvalTracker =
nullptr;
17788 Object getObject(
const Expr *E,
bool Mod)
const {
17790 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
17791 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
17792 return getObject(UO->getSubExpr(), Mod);
17793 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
17794 if (BO->getOpcode() == BO_Comma)
17795 return getObject(BO->getRHS(), Mod);
17796 if (Mod && BO->isAssignmentOp())
17797 return getObject(BO->getLHS(), Mod);
17798 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
17800 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
17801 return ME->getMemberDecl();
17802 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
17811 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
17813 Usage &
U = UI.Uses[UK];
17814 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
17818 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
17819 ModAsSideEffect->push_back(std::make_pair(O,
U));
17821 U.UsageExpr = UsageExpr;
17831 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
17832 UsageKind OtherKind,
bool IsModMod) {
17836 const Usage &
U = UI.Uses[OtherKind];
17837 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
17840 const Expr *Mod =
U.UsageExpr;
17841 const Expr *ModOrUse = UsageExpr;
17842 if (OtherKind == UK_Use)
17843 std::swap(Mod, ModOrUse);
17847 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
17848 : diag::warn_unsequenced_mod_use)
17850 UI.Diagnosed =
true;
17879 void notePreUse(Object O,
const Expr *UseExpr) {
17880 UsageInfo &UI = UsageMap[O];
17882 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
17885 void notePostUse(Object O,
const Expr *UseExpr) {
17886 UsageInfo &UI = UsageMap[O];
17887 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
17889 addUsage(O, UI, UseExpr, UK_Use);
17892 void notePreMod(Object O,
const Expr *ModExpr) {
17893 UsageInfo &UI = UsageMap[O];
17895 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
17896 checkUsage(O, UI, ModExpr, UK_Use,
false);
17899 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
17900 UsageInfo &UI = UsageMap[O];
17901 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
17903 addUsage(O, UI, ModExpr, UK);
17907 SequenceChecker(
Sema &S,
const Expr *E,
17909 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
17913 (void)this->WorkList;
17916 void VisitStmt(
const Stmt *S) {
17920 void VisitExpr(
const Expr *E) {
17922 Base::VisitStmt(E);
17926 for (
auto *Sub : CSE->
children()) {
17927 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
17942 void VisitCastExpr(
const CastExpr *E) {
17954 void VisitSequencedExpressions(
const Expr *SequencedBefore,
17955 const Expr *SequencedAfter) {
17956 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
17957 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
17958 SequenceTree::Seq OldRegion = Region;
17961 SequencedSubexpression SeqBefore(*
this);
17962 Region = BeforeRegion;
17963 Visit(SequencedBefore);
17966 Region = AfterRegion;
17967 Visit(SequencedAfter);
17969 Region = OldRegion;
17971 Tree.merge(BeforeRegion);
17972 Tree.merge(AfterRegion);
17980 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
17987 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17988 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
17994 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
18001 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
18002 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
18007 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
18019 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
18023 SequenceTree::Seq RHSRegion;
18024 SequenceTree::Seq LHSRegion;
18026 RHSRegion =
Tree.allocate(Region);
18027 LHSRegion =
Tree.allocate(Region);
18029 RHSRegion = Region;
18030 LHSRegion = Region;
18032 SequenceTree::Seq OldRegion = Region;
18048 SequencedSubexpression SeqBefore(*
this);
18049 Region = RHSRegion;
18053 Region = LHSRegion;
18056 if (O && isa<CompoundAssignOperator>(BO))
18057 notePostUse(O, BO);
18061 Region = LHSRegion;
18064 if (O && isa<CompoundAssignOperator>(BO))
18065 notePostUse(O, BO);
18067 Region = RHSRegion;
18075 Region = OldRegion;
18079 : UK_ModAsSideEffect);
18081 Tree.merge(RHSRegion);
18082 Tree.merge(LHSRegion);
18087 VisitBinAssign(CAO);
18090 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
18091 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
18095 return VisitExpr(UO);
18103 : UK_ModAsSideEffect);
18106 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
18107 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
18111 return VisitExpr(UO);
18115 notePostMod(O, UO, UK_ModAsSideEffect);
18124 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
18125 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
18126 SequenceTree::Seq OldRegion = Region;
18128 EvaluationTracker Eval(*
this);
18130 SequencedSubexpression Sequenced(*
this);
18131 Region = LHSRegion;
18138 bool EvalResult =
false;
18139 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
18140 bool ShouldVisitRHS = !EvalOK || !EvalResult;
18141 if (ShouldVisitRHS) {
18142 Region = RHSRegion;
18146 Region = OldRegion;
18147 Tree.merge(LHSRegion);
18148 Tree.merge(RHSRegion);
18157 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
18158 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
18159 SequenceTree::Seq OldRegion = Region;
18161 EvaluationTracker Eval(*
this);
18163 SequencedSubexpression Sequenced(*
this);
18164 Region = LHSRegion;
18170 bool EvalResult =
false;
18171 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
18172 bool ShouldVisitRHS = !EvalOK || EvalResult;
18173 if (ShouldVisitRHS) {
18174 Region = RHSRegion;
18178 Region = OldRegion;
18179 Tree.merge(LHSRegion);
18180 Tree.merge(RHSRegion);
18188 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
18204 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
18205 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
18206 SequenceTree::Seq OldRegion = Region;
18208 EvaluationTracker Eval(*
this);
18210 SequencedSubexpression Sequenced(*
this);
18211 Region = ConditionRegion;
18221 bool EvalResult =
false;
18222 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
18223 bool ShouldVisitTrueExpr = !EvalOK || EvalResult;
18224 bool ShouldVisitFalseExpr = !EvalOK || !EvalResult;
18225 if (ShouldVisitTrueExpr) {
18226 Region = TrueRegion;
18229 if (ShouldVisitFalseExpr) {
18230 Region = FalseRegion;
18234 Region = OldRegion;
18235 Tree.merge(ConditionRegion);
18236 Tree.merge(TrueRegion);
18237 Tree.merge(FalseRegion);
18240 void VisitCallExpr(
const CallExpr *CE) {
18252 SequencedSubexpression Sequenced(*
this);
18257 SequenceTree::Seq CalleeRegion;
18258 SequenceTree::Seq OtherRegion;
18259 if (SemaRef.getLangOpts().CPlusPlus17) {
18260 CalleeRegion = Tree.allocate(Region);
18261 OtherRegion = Tree.allocate(Region);
18263 CalleeRegion = Region;
18264 OtherRegion = Region;
18266 SequenceTree::Seq OldRegion = Region;
18269 Region = CalleeRegion;
18271 SequencedSubexpression Sequenced(*this);
18272 Visit(CE->getCallee());
18274 Visit(CE->getCallee());
18278 Region = OtherRegion;
18282 Region = OldRegion;
18284 Tree.merge(CalleeRegion);
18285 Tree.merge(OtherRegion);
18303 return VisitCallExpr(CXXOCE);
18314 case OO_MinusEqual:
18316 case OO_SlashEqual:
18317 case OO_PercentEqual:
18318 case OO_CaretEqual:
18321 case OO_LessLessEqual:
18322 case OO_GreaterGreaterEqual:
18323 SequencingKind = RHSBeforeLHS;
18327 case OO_GreaterGreater:
18333 SequencingKind = LHSBeforeRHS;
18337 SequencingKind = LHSBeforeRest;
18341 SequencingKind = NoSequencing;
18345 if (SequencingKind == NoSequencing)
18346 return VisitCallExpr(CXXOCE);
18349 SequencedSubexpression Sequenced(*
this);
18352 assert(SemaRef.getLangOpts().CPlusPlus17 &&
18353 "Should only get there with C++17 and above!");
18354 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
18355 "Should only get there with an overloaded binary operator"
18356 " or an overloaded call operator!");
18358 if (SequencingKind == LHSBeforeRest) {
18359 assert(CXXOCE->getOperator() == OO_Call &&
18360 "We should only have an overloaded call operator here!");
18369 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
18370 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
18371 SequenceTree::Seq OldRegion = Region;
18373 assert(CXXOCE->getNumArgs() >= 1 &&
18374 "An overloaded call operator must have at least one argument"
18375 " for the postfix-expression!");
18376 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
18377 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
18378 CXXOCE->getNumArgs() - 1);
18382 Region = PostfixExprRegion;
18383 SequencedSubexpression Sequenced(*this);
18384 Visit(PostfixExpr);
18388 Region = ArgsRegion;
18389 for (const Expr *Arg : Args)
18392 Region = OldRegion;
18393 Tree.merge(PostfixExprRegion);
18394 Tree.merge(ArgsRegion);
18396 assert(CXXOCE->getNumArgs() == 2 &&
18397 "Should only have two arguments here!");
18398 assert((SequencingKind == LHSBeforeRHS ||
18399 SequencingKind == RHSBeforeLHS) &&
18400 "Unexpected sequencing kind!");
18404 const Expr *E1 = CXXOCE->getArg(0);
18405 const Expr *E2 = CXXOCE->getArg(1);
18406 if (SequencingKind == RHSBeforeLHS)
18409 return VisitSequencedExpressions(E1, E2);
18416 SequencedSubexpression Sequenced(*
this);
18419 return VisitExpr(CCE);
18422 SequenceExpressionsInOrder(
18428 return VisitExpr(ILE);
18431 SequenceExpressionsInOrder(ILE->
inits());
18443 SequenceTree::Seq
Parent = Region;
18444 for (
const Expr *E : ExpressionList) {
18448 Elts.push_back(Region);
18454 for (
unsigned I = 0; I < Elts.size(); ++I)
18455 Tree.merge(Elts[I]);
18459 SequenceChecker::UsageInfo::UsageInfo() =
default;
18463 void Sema::CheckUnsequencedOperations(
const Expr *E) {
18465 WorkList.push_back(E);
18466 while (!WorkList.empty()) {
18467 const Expr *Item = WorkList.pop_back_val();
18468 SequenceChecker(*
this, Item, WorkList);
18473 bool IsConstexpr) {
18475 IsConstexpr || isa<ConstantExpr>(E));
18476 CheckImplicitConversions(E, CheckLoc);
18478 CheckUnsequencedOperations(E);
18480 CheckForIntOverflow(E);
18481 DiagnoseMisalignedMembers();
18494 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
18498 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
18502 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
18516 S.
Diag(Loc, diag::err_array_star_in_function_definition);
18525 bool CheckParameterNames) {
18526 bool HasInvalidParm =
false;
18528 assert(Param &&
"null in a parameter list");
18537 if (!Param->isInvalidDecl() &&
18538 (RequireCompleteType(Param->getLocation(), Param->getType(),
18539 diag::err_typecheck_decl_incomplete_type) ||
18540 RequireNonAbstractType(Param->getBeginLoc(), Param->getOriginalType(),
18541 diag::err_abstract_type_in_decl,
18542 AbstractParamType))) {
18543 Param->setInvalidDecl();
18544 HasInvalidParm =
true;
18549 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
18550 !Param->isImplicit() && !getLangOpts().
CPlusPlus) {
18552 if (!getLangOpts().
C23)
18553 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c23);
18561 QualType PType = Param->getOriginalType();
18569 if (!Param->isInvalidDecl()) {
18571 if (!ClassDecl->isInvalidDecl() &&
18572 !ClassDecl->hasIrrelevantDestructor() &&
18573 !ClassDecl->isDependentContext() &&
18574 ClassDecl->isParamDestroyedInCallee()) {
18576 MarkFunctionReferenced(Param->getLocation(), Destructor);
18577 DiagnoseUseOfDecl(Destructor, Param->getLocation());
18586 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
18587 if (!Param->getType().isConstQualified())
18588 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
18592 if (LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
18597 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
18598 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
18603 if (!Param->isInvalidDecl() &&
18605 Param->setInvalidDecl();
18606 HasInvalidParm =
true;
18607 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
18611 return HasInvalidParm;
18614 std::optional<std::pair<
18623 static std::pair<CharUnits, CharUnits>
18631 if (
Base->isVirtual()) {
18638 BaseAlignment =
std::min(BaseAlignment, NonVirtualAlignment);
18645 DerivedType =
Base->getType();
18648 return std::make_pair(BaseAlignment,
Offset);
18652 static std::optional<std::pair<CharUnits, CharUnits>>
18658 return std::nullopt;
18663 return std::nullopt;
18670 return std::make_pair(
P->first,
P->second +
Offset);
18676 return std::make_pair(
18677 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
18683 std::optional<std::pair<
18691 case Stmt::CStyleCastExprClass:
18692 case Stmt::CXXStaticCastExprClass:
18693 case Stmt::ImplicitCastExprClass: {
18694 auto *CE = cast<CastExpr>(E);
18695 const Expr *From = CE->getSubExpr();
18696 switch (CE->getCastKind()) {
18701 case CK_UncheckedDerivedToBase:
18702 case CK_DerivedToBase: {
18712 case Stmt::ArraySubscriptExprClass: {
18713 auto *ASE = cast<ArraySubscriptExpr>(E);
18717 case Stmt::DeclRefExprClass: {
18718 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
18721 if (!VD->getType()->isReferenceType()) {
18723 if (VD->hasDependentAlignment())
18732 case Stmt::MemberExprClass: {
18733 auto *ME = cast<MemberExpr>(E);
18734 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
18738 std::optional<std::pair<CharUnits, CharUnits>>
P;
18747 return std::make_pair(
P->first,
18750 case Stmt::UnaryOperatorClass: {
18751 auto *UO = cast<UnaryOperator>(E);
18760 case Stmt::BinaryOperatorClass: {
18761 auto *BO = cast<BinaryOperator>(E);
18772 return std::nullopt;
18777 std::optional<std::pair<
18786 case Stmt::CStyleCastExprClass:
18787 case Stmt::CXXStaticCastExprClass:
18788 case Stmt::ImplicitCastExprClass: {
18789 auto *CE = cast<CastExpr>(E);
18790 const Expr *From = CE->getSubExpr();
18791 switch (CE->getCastKind()) {
18796 case CK_ArrayToPointerDecay:
18798 case CK_UncheckedDerivedToBase:
18799 case CK_DerivedToBase: {
18809 case Stmt::CXXThisExprClass: {
18814 case Stmt::UnaryOperatorClass: {
18815 auto *UO = cast<UnaryOperator>(E);
18820 case Stmt::BinaryOperatorClass: {
18821 auto *BO = cast<BinaryOperator>(E);
18829 if (
Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
18830 std::swap(LHS, RHS);
18840 return std::nullopt;
18845 std::optional<std::pair<CharUnits, CharUnits>>
P =
18849 return P->first.alignmentAtOffset(
P->second);
18860 if (getDiagnostics().isIgnored(diag::warn_cast_align, TRange.
getBegin()))
18869 if (!DestPtr)
return;
18875 if (DestAlign.
isOne())
return;
18879 if (!SrcPtr)
return;
18890 if (SrcAlign >= DestAlign)
return;
18895 <<
static_cast<unsigned>(DestAlign.
getQuantity())
18899 void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
18901 bool AllowOnePastEnd,
bool IndexNegated) {
18903 if (isConstantEvaluatedContext())
18910 const Type *EffectiveType =
18917 StrictFlexArraysLevel = getLangOpts().getStrictFlexArraysLevel();
18919 const Type *BaseType =
18921 bool IsUnboundedArray =
18923 Context, StrictFlexArraysLevel,
18934 if (IndexNegated) {
18935 index.setIsUnsigned(
false);
18939 if (IsUnboundedArray) {
18942 if (index.isUnsigned() || !index.isNegative()) {
18943 const auto &ASTC = getASTContext();
18944 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
18946 if (index.getBitWidth() < AddrBits)
18947 index = index.zext(AddrBits);
18948 std::optional<CharUnits> ElemCharUnits =
18949 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
18952 if (!ElemCharUnits || ElemCharUnits->isZero())
18954 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
18959 if (index.getActiveBits() <= AddrBits) {
18963 Product = Product.umul_ov(ElemBytes, Overflow);
18964 if (!Overflow && Product.getActiveBits() <= AddrBits)
18970 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
18971 MaxElems = MaxElems.zext(
std::max(AddrBits + 1, ElemBytes.getBitWidth()));
18973 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
18974 MaxElems = MaxElems.udiv(ElemBytes);
18977 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
18978 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
18982 DiagRuntimeBehavior(BaseExpr->
getBeginLoc(), BaseExpr,
18984 <<
toString(index, 10,
true) << AddrBits
18985 << (
unsigned)ASTC.toBits(*ElemCharUnits)
18988 << (
unsigned)MaxElems.getLimitedValue(~0
U)
18993 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
18995 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
18997 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
18998 ND = ME->getMemberDecl();
19002 PDiag(diag::note_array_declared_here) << ND);
19007 if (index.isUnsigned() || !index.isNegative()) {
19019 if (BaseType != EffectiveType) {
19027 if (!ptrarith_typesize)
19030 if (ptrarith_typesize != array_typesize) {
19032 uint64_t ratio = array_typesize / ptrarith_typesize;
19036 if (ptrarith_typesize * ratio == array_typesize)
19041 if (size.getBitWidth() > index.getBitWidth())
19042 index = index.zext(size.getBitWidth());
19043 else if (size.getBitWidth() < index.getBitWidth())
19044 size = size.zext(index.getBitWidth());
19050 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
19059 if (SourceMgr.isInSystemHeader(RBracketLoc)) {
19061 SourceMgr.getSpellingLoc(IndexExpr->
getBeginLoc());
19062 if (SourceMgr.isWrittenInSameFile(RBracketLoc, IndexLoc))
19067 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
19068 : diag::warn_ptr_arith_exceeds_bounds;
19069 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
19072 DiagRuntimeBehavior(
19077 unsigned DiagID = diag::warn_array_index_precedes_bounds;
19079 DiagID = diag::warn_ptr_arith_precedes_bounds;
19080 if (index.isNegative()) index = -index;
19083 DiagRuntimeBehavior(BaseExpr->
getBeginLoc(), BaseExpr,
19084 PDiag(DiagID) <<
toString(index, 10,
true)
19090 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
19092 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
19094 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
19095 ND = ME->getMemberDecl();
19099 PDiag(diag::note_array_declared_here) << ND);
19102 void Sema::CheckArrayAccess(
const Expr *
expr) {
19103 int AllowOnePastEnd = 0;
19105 expr =
expr->IgnoreParenImpCasts();
19106 switch (
expr->getStmtClass()) {
19107 case Stmt::ArraySubscriptExprClass: {
19110 AllowOnePastEnd > 0);
19114 case Stmt::MemberExprClass: {
19115 expr = cast<MemberExpr>(
expr)->getBase();
19118 case Stmt::OMPArraySectionExprClass: {
19122 nullptr, AllowOnePastEnd > 0);
19125 case Stmt::UnaryOperatorClass: {
19141 case Stmt::ConditionalOperatorClass: {
19144 CheckArrayAccess(lhs);
19146 CheckArrayAccess(rhs);
19149 case Stmt::CXXOperatorCallExprClass: {
19150 const auto *OCE = cast<CXXOperatorCallExpr>(
expr);
19151 for (
const auto *Arg : OCE->arguments())
19152 CheckArrayAccess(Arg);
19165 struct RetainCycleOwner {
19169 bool Indirect =
false;
19171 RetainCycleOwner() =
default;
19173 void setLocsFrom(
Expr *e) {
19190 owner.Variable =
var;
19192 owner.setLocsFrom(ref);
19200 switch (
cast->getCastKind()) {
19202 case CK_LValueBitCast:
19203 case CK_LValueToRValue:
19204 case CK_ARCReclaimReturnedObject:
19205 e =
cast->getSubExpr();
19222 if (ref->isFreeIvar()) owner.setLocsFrom(ref);
19223 owner.Indirect =
true;
19227 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) {
19228 VarDecl *
var = dyn_cast<VarDecl>(ref->getDecl());
19229 if (!
var)
return false;
19234 if (
member->isArrow())
return false;
19244 = dyn_cast<ObjCPropertyRefExpr>(pseudo->getSyntacticForm()
19246 if (!pre)
return false;
19249 if (!property->isRetaining() &&
19250 !(property->getPropertyIvarDecl() &&
19251 property->getPropertyIvarDecl()->getType()
19255 owner.Indirect =
true;
19258 if (!owner.Variable)
19264 e =
const_cast<Expr*
>(cast<OpaqueValueExpr>(pre->
getBase())
19265 ->getSourceExpr());
19279 Expr *Capturer =
nullptr;
19280 bool VarWillBeReased =
false;
19287 if (ref->
getDecl() == Variable && !Capturer)
19292 if (Capturer)
return;
19298 void VisitBlockExpr(
BlockExpr *block) {
19305 if (Capturer)
return;
19311 if (!Variable || VarWillBeReased || BinOp->
getOpcode() != BO_Assign)
19314 if (
const DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(LHS)) {
19315 if (DRE->
getDecl() != Variable)
19319 std::optional<llvm::APSInt>
Value;
19321 (RHS && (
Value = RHS->getIntegerConstantExpr(Context)) &&
19333 assert(owner.Variable && owner.Loc.isValid());
19340 if (
Cmd.isUnarySelector() &&
Cmd.getNameForSlot(0) ==
"copy") {
19341 e = ME->getInstanceReceiver();
19346 }
else if (
CallExpr *CE = dyn_cast<CallExpr>(e)) {
19351 if (FnI && FnI->
isStr(
"_Block_copy")) {
19358 BlockExpr *block = dyn_cast<BlockExpr>(e);
19362 FindCaptureVisitor visitor(S.
Context, owner.Variable);
19364 return visitor.VarWillBeReased ? nullptr : visitor.Capturer;
19368 RetainCycleOwner &owner) {
19370 assert(owner.Variable && owner.Loc.isValid());
19374 S.
Diag(owner.Loc, diag::note_arc_retain_cycle_owner)
19375 << owner.Indirect << owner.Range;
19384 str = str.ltrim(
'_');
19385 if (str.starts_with(
"set"))
19386 str = str.substr(3);
19387 else if (str.starts_with(
"add")) {
19389 if (sel.
getNumArgs() == 1 && str.starts_with(
"addOperationWithBlock"))
19391 str = str.substr(3);
19395 if (str.empty())
return true;
19399 static std::optional<int>
19401 bool IsMutableArray = S.
NSAPIObj->isSubclassOfNSClass(
19402 Message->getReceiverInterface(),
19404 if (!IsMutableArray) {
19405 return std::nullopt;
19408 Selector Sel = Message->getSelector();
19410 std::optional<NSAPI::NSArrayMethodKind> MKOpt =
19411 S.
NSAPIObj->getNSArrayMethodKind(Sel);
19413 return std::nullopt;
19427 return std::nullopt;
19430 return std::nullopt;
19433 static std::optional<int>
19435 bool IsMutableDictionary = S.
NSAPIObj->isSubclassOfNSClass(
19436 Message->getReceiverInterface(),
19438 if (!IsMutableDictionary) {
19439 return std::nullopt;
19442 Selector Sel = Message->getSelector();
19444 std::optional<NSAPI::NSDictionaryMethodKind> MKOpt =
19445 S.
NSAPIObj->getNSDictionaryMethodKind(Sel);
19447 return std::nullopt;
19459 return std::nullopt;
19462 return std::nullopt;
19467 bool IsMutableSet = S.
NSAPIObj->isSubclassOfNSClass(
19468 Message->getReceiverInterface(),
19471 bool IsMutableOrderedSet = S.
NSAPIObj->isSubclassOfNSClass(
19472 Message->getReceiverInterface(),
19474 if (!IsMutableSet && !IsMutableOrderedSet) {
19475 return std::nullopt;
19478 Selector Sel = Message->getSelector();
19480 std::optional<NSAPI::NSSetMethodKind> MKOpt =
19481 S.
NSAPIObj->getNSSetMethodKind(Sel);
19483 return std::nullopt;
19498 return std::nullopt;
19502 if (!Message->isInstanceMessage()) {
19506 std::optional<int> ArgOpt;
19514 int ArgIndex = *ArgOpt;
19516 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
19522 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19523 if (ArgRE->isObjCSelfExpr()) {
19524 Diag(Message->getSourceRange().getBegin(),
19525 diag::warn_objc_circular_container)
19526 << ArgRE->getDecl() << StringRef(
"'super'");
19530 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
19536 if (
DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {
19537 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
19538 if (ReceiverRE->getDecl() == ArgRE->getDecl()) {
19540 Diag(Message->getSourceRange().getBegin(),
19541 diag::warn_objc_circular_container)
19543 if (!ArgRE->isObjCSelfExpr()) {
19545 diag::note_objc_circular_container_declared_here)
19550 }
else if (
ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {
19552 if (IvarRE->getDecl() == IvarArgRE->getDecl()) {
19554 Diag(Message->getSourceRange().getBegin(),
19555 diag::warn_objc_circular_container)
19558 diag::note_objc_circular_container_declared_here)
19573 RetainCycleOwner owner;
19579 owner.Variable = getCurMethodDecl()->getSelfDecl();
19586 for (
unsigned i = 0, e = msg->
getNumArgs(); i != e; ++i) {
19589 if (MD && MD->
parameters()[i]->hasAttr<NoEscapeAttr>())
19598 RetainCycleOwner owner;
19607 RetainCycleOwner Owner;
19621 Expr *RHS,
bool isProperty) {
19633 S.
Diag(Loc, diag::warn_arc_literal_assign)
19635 << (isProperty ? 0 : 1)
19643 Expr *RHS,
bool isProperty) {
19646 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19647 S.
Diag(Loc, diag::warn_arc_retained_assign)
19649 << (isProperty ? 0 : 1)
19653 RHS =
cast->getSubExpr();
19695 if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))
19696 getCurFunction()->markSafeWeakUse(LHS);
19699 if (checkUnsafeAssigns(Loc, LHSType, RHS))
19724 if (
cast->getCastKind() == CK_ARCConsumeObject) {
19725 Diag(Loc, diag::warn_arc_retained_property_assign)
19729 RHS =
cast->getSubExpr();
19752 bool StmtLineInvalid;
19755 if (StmtLineInvalid)
19758 bool BodyLineInvalid;
19761 if (BodyLineInvalid)
19765 if (StmtLine != BodyLine)
19776 if (CurrentInstantiationScope)
19780 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19789 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19793 const Stmt *PossibleBody) {
19794 assert(!CurrentInstantiationScope);
19799 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
19800 StmtLoc = FS->getRParenLoc();
19801 Body = FS->getBody();
19802 DiagID = diag::warn_empty_for_body;
19803 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
19804 StmtLoc = WS->getRParenLoc();
19805 Body = WS->getBody();
19806 DiagID = diag::warn_empty_while_body;
19811 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
19816 if (Diags.isIgnored(DiagID, NBody->
getSemiLoc()))
19834 bool ProbableTypo = isa<CompoundStmt>(PossibleBody);
19835 if (!ProbableTypo) {
19836 bool BodyColInvalid;
19837 unsigned BodyCol = SourceMgr.getPresumedColumnNumber(
19839 if (BodyColInvalid)
19842 bool StmtColInvalid;
19844 SourceMgr.getPresumedColumnNumber(S->getBeginLoc(), &StmtColInvalid);
19845 if (StmtColInvalid)
19848 if (BodyCol > StmtCol)
19849 ProbableTypo =
true;
19852 if (ProbableTypo) {
19854 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
19863 if (Diags.isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
19866 if (inTemplateInstantiation())
19875 if (
const auto *CE = dyn_cast<CallExpr>(RHSExpr);
19877 RHSExpr = CE->
getArg(0);
19878 else if (
const auto *CXXSCE = dyn_cast<CXXStaticCastExpr>(RHSExpr);
19879 CXXSCE && CXXSCE->isXValue())
19880 RHSExpr = CXXSCE->getSubExpr();
19884 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
19885 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
19888 if (LHSDeclRef && RHSDeclRef) {
19895 auto D =
Diag(OpLoc, diag::warn_self_move)
19899 getSelfAssignmentClassMemberCandidate(RHSDeclRef->
getDecl()))
19911 const Expr *LHSBase = LHSExpr;
19912 const Expr *RHSBase = RHSExpr;
19913 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
19914 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
19915 if (!LHSME || !RHSME)
19918 while (LHSME && RHSME) {
19925 LHSME = dyn_cast<MemberExpr>(LHSBase);
19926 RHSME = dyn_cast<MemberExpr>(RHSBase);
19929 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
19930 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
19931 if (LHSDeclRef && RHSDeclRef) {
19938 Diag(OpLoc, diag::warn_self_move)
19944 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
19945 Diag(OpLoc, diag::warn_self_move)
19968 bool AreUnionMembers =
false) {
19969 [[maybe_unused]]
const Type *Field1Parent =
19971 [[maybe_unused]]
const Type *Field2Parent =
19976 "Can't evaluate layout compatibility between a struct field and a "
19979 (AreUnionMembers && Field1Parent->
isUnionType())) &&
19980 "AreUnionMembers should be 'true' for union fields (only).");
19993 if (Bits1 != Bits2)
19997 if (Field1->
hasAttr<clang::NoUniqueAddressAttr>() ||
19998 Field2->
hasAttr<clang::NoUniqueAddressAttr>())
20001 if (!AreUnionMembers &&
20013 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
20018 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
20023 Base1 = D1CXX->bases_begin(),
20024 BaseEnd1 = D1CXX->bases_end(),
20027 ++Base1, ++Base2) {
20031 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
20033 if (D2CXX->getNumBases() > 0)
20042 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
20046 if (Field1 != Field1End || Field2 != Field2End)
20057 for (
auto *Field2 : RD2->
fields())
20058 UnmatchedFields.insert(Field2);
20060 for (
auto *Field1 : RD1->
fields()) {
20062 I = UnmatchedFields.begin(),
20063 E = UnmatchedFields.end();
20065 for ( ; I != E; ++I) {
20067 bool Result = UnmatchedFields.erase(*I);
20077 return UnmatchedFields.empty();
20103 if (C.hasSameType(T1, T2))
20112 if (TC1 == Type::Enum) {
20114 cast<EnumType>(T1)->getDecl(),
20115 cast<EnumType>(T2)->getDecl());
20121 cast<RecordType>(T1)->getDecl(),
20122 cast<RecordType>(T2)->getDecl());
20136 QualType BaseT =
Base->getType()->getCanonicalTypeUnqualified();
20140 getASTContext().hasSameType(BaseT, DerivedT))
20168 bool isConstantEvaluated) {
20176 case Stmt::UnaryOperatorClass: {
20185 case Stmt::DeclRefExprClass: {
20186 const DeclRefExpr *DRE = cast<DeclRefExpr>(TypeExpr);
20191 case Stmt::IntegerLiteralClass: {
20194 if (MagicValueAPInt.getActiveBits() <= 64) {
20195 *MagicValue = MagicValueAPInt.getZExtValue();
20201 case Stmt::BinaryConditionalOperatorClass:
20202 case Stmt::ConditionalOperatorClass: {
20204 cast<AbstractConditionalOperator>(TypeExpr);
20207 isConstantEvaluated)) {
20217 case Stmt::BinaryOperatorClass: {
20220 TypeExpr = BO->
getRHS();
20250 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
20253 bool isConstantEvaluated) {
20254 FoundWrongKind =
false;
20261 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
20265 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
20266 if (I->getArgumentKind() != ArgumentKind) {
20267 FoundWrongKind =
true;
20270 TypeInfo.Type = I->getMatchingCType();
20271 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
20272 TypeInfo.MustBeNull = I->getMustBeNull();
20283 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
20284 if (I == MagicValues->end())
20293 bool LayoutCompatible,
20295 if (!TypeTagForDatatypeMagicValues)
20296 TypeTagForDatatypeMagicValues.reset(
20297 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
20300 (*TypeTagForDatatypeMagicValues)[Magic] =
20316 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
20317 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
20318 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
20319 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
20322 void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
20326 bool IsPointerAttr =
Attr->getIsPointer();
20329 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
20330 if (TypeTagIdxAST >= ExprArgs.size()) {
20331 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
20332 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
20335 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
20336 bool FoundWrongKind;
20339 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
20340 TypeInfo, isConstantEvaluatedContext())) {
20341 if (FoundWrongKind)
20343 diag::warn_type_tag_for_datatype_wrong_kind)
20349 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
20350 if (ArgumentIdxAST >= ExprArgs.size()) {
20351 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
20352 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
20355 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
20356 if (IsPointerAttr) {
20358 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
20359 if (ICE->getType()->isVoidPointerType() &&
20360 ICE->getCastKind() == CK_BitCast)
20361 ArgumentExpr = ICE->getSubExpr();
20374 diag::warn_type_safety_null_pointer_required)
20386 bool mismatch =
false;
20388 mismatch = !Context.
hasSameType(ArgumentType, RequiredType);
20409 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
20410 << ArgumentType << ArgumentKind
20411 <<
TypeInfo.LayoutCompatible << RequiredType
20418 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
20422 for (MisalignedMember &m : MisalignedMembers) {
20428 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
20431 MisalignedMembers.clear();
20438 if (isa<UnaryOperator>(E) &&
20439 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
20440 auto *Op = cast<UnaryOperator>(E)->getSubExpr()->
IgnoreParens();
20441 if (isa<MemberExpr>(Op)) {
20442 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
20443 if (MA != MisalignedMembers.end() &&
20448 MisalignedMembers.erase(MA);
20457 const auto *ME = dyn_cast<MemberExpr>(E);
20469 bool AnyIsPacked =
false;
20471 QualType BaseType = ME->getBase()->getType();
20481 auto *FD = dyn_cast<FieldDecl>(MD);
20487 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
20488 ReverseMemberChain.push_back(FD);
20491 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
20493 assert(TopME &&
"We did not compute a topmost MemberExpr!");
20500 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
20504 if (!DRE && !isa<CXXThisExpr>(TopBase))
20511 if (ExpectedAlignment.
isOne())
20516 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
20521 ReverseMemberChain.back()->getParent()->getTypeForDecl());
20525 if (DRE && !TopME->
isArrow()) {
20528 CompleteObjectAlignment =
20533 if (
Offset % ExpectedAlignment != 0 ||
20536 CompleteObjectAlignment < ExpectedAlignment) {
20547 for (
FieldDecl *FDI : ReverseMemberChain) {
20548 if (FDI->hasAttr<PackedAttr>() ||
20549 FDI->getParent()->hasAttr<PackedAttr>()) {
20557 assert(FD &&
"We did not find a packed FieldDecl!");
20558 Action(E, FD->
getParent(), FD, Alignment);
20562 void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
20563 using namespace std::placeholders;
20565 RefersToMemberWithReducedAlignment(
20566 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
20570 bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
20588 bool Sema::BuiltinElementwiseMath(
CallExpr *TheCall) {
20590 if (BuiltinVectorMath(TheCall, Res))
20598 if (BuiltinVectorMath(TheCall, Res))
20602 TheCall->
setType(VecTy0->getElementType());
20617 Res = UsualArithmeticConversions(A, B, TheCall->
getExprLoc(), ACK_Comparison);
20626 diag::err_typecheck_call_different_arg_types)
20637 bool Sema::BuiltinElementwiseTernaryMath(
CallExpr *TheCall,
20638 bool CheckForFloatArgs) {
20643 for (
int I = 0; I < 3; ++I) {
20647 Args[I] = Converted.
get();
20650 if (CheckForFloatArgs) {
20651 int ArgOrdinal = 1;
20652 for (
Expr *Arg : Args) {
20654 Arg->
getType(), ArgOrdinal++))
20658 int ArgOrdinal = 1;
20659 for (
Expr *Arg : Args) {
20666 for (
int I = 1; I < 3; ++I) {
20667 if (Args[0]->getType().getCanonicalType() !=
20668 Args[I]->getType().getCanonicalType()) {
20669 return Diag(Args[0]->getBeginLoc(),
20670 diag::err_typecheck_call_different_arg_types)
20671 << Args[0]->getType() << Args[I]->getType();
20674 TheCall->
setArg(I, Args[I]);
20677 TheCall->
setType(Args[0]->getType());
20681 bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
20693 bool Sema::BuiltinNonDeterministicValue(
CallExpr *TheCall) {
20702 << 1 << 0 << TyArg;
20716 Expr *Matrix = MatrixArg.
get();
20721 << 1 << 1 << Matrix->
getType();
20728 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
20731 TheCall->
setType(ResultType);
20734 TheCall->
setArg(0, Matrix);
20739 static std::optional<unsigned>
20742 std::optional<llvm::APSInt>
Value =
20760 if (!getLangOpts().MatrixTypes) {
20768 unsigned PtrArgIdx = 0;
20774 bool ArgError =
false;
20778 ExprResult PtrConv = DefaultFunctionArrayLvalueConversion(PtrExpr);
20781 PtrExpr = PtrConv.
get();
20782 TheCall->
setArg(0, PtrExpr);
20793 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20800 << PtrArgIdx + 1 << 2
20807 auto ApplyArgumentConversions = [
this](
Expr *E) {
20808 ExprResult Conv = DefaultLvalueConversion(E);
20816 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
20818 RowsExpr = RowsConv.
get();
20819 TheCall->
setArg(1, RowsExpr);
20821 RowsExpr =
nullptr;
20823 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
20825 ColumnsExpr = ColumnsConv.
get();
20826 TheCall->
setArg(2, ColumnsExpr);
20828 ColumnsExpr =
nullptr;
20839 std::optional<unsigned> MaybeRows;
20843 std::optional<unsigned> MaybeColumns;
20848 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
20851 StrideExpr = StrideConv.
get();
20852 TheCall->
setArg(3, StrideExpr);
20855 if (std::optional<llvm::APSInt>
Value =
20858 if (Stride < *MaybeRows) {
20860 diag::err_builtin_matrix_stride_too_small);
20866 if (ArgError || !MaybeRows || !MaybeColumns)
20879 unsigned PtrArgIdx = 1;
20884 bool ArgError =
false;
20887 ExprResult MatrixConv = DefaultLvalueConversion(MatrixExpr);
20890 MatrixExpr = MatrixConv.
get();
20891 TheCall->
setArg(0, MatrixExpr);
20901 << 1 << 1 << MatrixExpr->
getType();
20906 ExprResult PtrConv = DefaultFunctionArrayLvalueConversion(PtrExpr);
20909 PtrExpr = PtrConv.
get();
20910 TheCall->
setArg(1, PtrExpr);
20921 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
20926 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
20931 !Context.
hasSameType(ElementTy, MatrixTy->getElementType())) {
20933 diag::err_builtin_matrix_pointer_arg_mismatch)
20934 << ElementTy << MatrixTy->getElementType();
20942 ExprResult StrideConv = DefaultLvalueConversion(StrideExpr);
20946 StrideConv = tryConvertExprToType(StrideConv.
get(), Context.
getSizeType());
20949 StrideExpr = StrideConv.
get();
20950 TheCall->
setArg(2, StrideExpr);
20955 if (std::optional<llvm::APSInt>
Value =
20958 if (Stride < MatrixTy->getNumRows()) {
20960 diag::err_builtin_matrix_stride_too_small);
20977 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
20978 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
20980 diag::err_wasm_builtin_arg_must_be_table_type)
20983 ElTy = ATy->getElementType();
20989 unsigned ArgIndex) {
20993 diag::err_wasm_builtin_arg_must_be_integer_type)
21001 bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
21024 bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
21042 bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
21056 bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
21067 diag::err_wasm_builtin_arg_must_match_table_element_type)
21080 bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
21094 diag::err_wasm_builtin_arg_must_match_table_element_type)
21107 bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
21122 diag::err_wasm_builtin_arg_must_match_table_element_type)
21126 for (
int I = 2; I <= 4; I++) {
21138 void Sema::CheckTCBEnforcement(
const SourceLocation CallExprLoc,
21141 if (isUnevaluatedContext())
21144 const NamedDecl *Caller = getCurFunctionOrMethodDecl();
21146 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
21151 llvm::StringSet<> CalleeTCBs;
21152 for (
const auto *A :
Callee->specific_attrs<EnforceTCBAttr>())
21153 CalleeTCBs.insert(A->getTCBName());
21154 for (
const auto *A :
Callee->specific_attrs<EnforceTCBLeafAttr>())
21155 CalleeTCBs.insert(A->getTCBName());
21159 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
21160 StringRef CallerTCB = A->getTCBName();
21161 if (CalleeTCBs.count(CallerTCB) == 0) {
21162 this->
Diag(CallExprLoc, diag::warn_tcb_enforcement_violation)
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
Provides definitions for the various language-specific address spaces.
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Target Target
llvm::MachO::Record Record
Defines the clang::OpenCLOptions class.
Defines an enumeration for C++ overloaded operators.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
static bool BuiltinReserveRWPipe(Sema &S, CallExpr *Call)
static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, const ValueDecl **VD, uint64_t *MagicValue, bool isConstantEvaluated)
Given a type tag expression find the type tag itself.
static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, bool InConstantContext, bool Approximate)
Pseudo-evaluate the given integer expression, estimating the range of values it might take.
static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T)
static QualType getSizeOfArgType(const Expr *E)
If E is a sizeof expression, returns its argument type.
static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc)
static std::optional< unsigned > getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S)
static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, IdentifierInfo *FnName, SourceLocation FnLoc, SourceLocation RParenLoc)
Takes the expression passed to the size_t parameter of functions such as memcmp, strncat,...
static std::pair< QualType, StringRef > shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy, const Expr *E)
static ExprResult PointerAuthSignGenericData(Sema &S, CallExpr *Call)
static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext)
Diagnose an implicit cast from a floating point value to an integer value.
static void CheckFormatString(Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers)
static ExprResult PointerAuthStrip(Sema &S, CallExpr *Call)
static bool considerVariable(VarDecl *var, Expr *ref, RetainCycleOwner &owner)
Consider whether capturing the given variable can possibly lead to a retain cycle.
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC, bool *ICContext=nullptr, bool IsListInit=false)
static bool IsSameFloatAfterCast(const llvm::APFloat &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt)
Checks whether the given value, which currently has the given source semantics, has the same value wh...
static StringLiteralCheckType checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, Sema::VariadicCallType CallType, bool InFunctionCall, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers=false)
static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth)
static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool)
static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow=false)
Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg)
OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local void*, which is a requirem...
static bool isX86_32Builtin(unsigned BuiltinID)
static void AnalyzeComparison(Sema &S, BinaryOperator *E)
Implements -Wsign-compare.
static void sumOffsets(llvm::APSInt &Offset, llvm::APSInt Addend, BinaryOperatorKind BinOpKind, bool AddendIsRight)
static QualType GetExprType(const Expr *E)
static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC)
static bool OpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17.6 - Check the argument to the get_kernel_work_group_size and get_kernel_prefe...
static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant)
static AbsoluteValueKind getAbsoluteValueKind(QualType T)
bool CheckNoDoubleVectors(Sema *S, CallExpr *TheCall)
static bool isKnownToHaveUnsignedValue(Expr *E)
static const UnaryExprOrTypeTraitExpr * getAsSizeOfExpr(const Expr *E)
static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall)
static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout structs are layout-compatible.
bool CheckUnsignedIntRepresentation(Sema *S, CallExpr *TheCall)
bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall)
static unsigned RFT(unsigned t, bool shift=false, bool ForceQuad=false)
static bool hasArmZAState(const FunctionDecl *FD)
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntType)
Diagnose integer type and any valid implicit conversion to it.
static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op)
static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID)
static llvm::APSInt getSYCLAllocaDefaultSize(const ASTContext &Ctx, const VarDecl *VD)
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E)
Analyze the given compound assignment for the possible losing of floating-point precision.
static bool doesExprLikelyComputeSize(const Expr *SizeofExpr)
Detect if SizeofExpr is likely to calculate the sizeof an object.
static const Expr * getSizeOfExprArg(const Expr *E)
If E is a sizeof expression, returns its argument expression, otherwise returns NULL.
static bool isObjCSignedCharBool(Sema &S, QualType Ty)
static bool checkIntelFPGARegArgument(Sema &S, QualType ArgType, SourceLocation &Loc)
static bool OpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call)
static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall)
Check the number of arguments and set the result type to the argument type.
bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall)
static bool isValidBPFPreserveTypeInfoArg(Expr *Arg)
static bool CheckForReference(Sema &SemaRef, const Expr *E, const PartialDiagnostic &PD)
static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID)
Check that the value argument for __builtin_is_aligned(value, alignment) and __builtin_aligned_{up,...
static std::optional< int > GetNSMutableDictionaryArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool BuiltinRWPipe(Sema &S, CallExpr *Call)
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
Check conversion of given expression to boolean.
static bool checkPointerAuthValue(Sema &S, Expr *&Arg, PointerAuthOpKind OpKind)
static bool checkArgCountAtLeast(Sema &S, CallExpr *Call, unsigned MinArgCount)
Checks that a call expression's argument count is at least the desired number.
static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call)
Diagnose cases like 'memset(buf, sizeof(buf), 0)', which should have the last two arguments transpose...
static bool checkPointerAuthEnabled(Sema &S, Expr *E)
static std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range)
static std::pair< CharUnits, CharUnits > getDerivedToBaseAlignmentAndOffset(const CastExpr *CE, QualType DerivedType, CharUnits BaseAlignment, CharUnits Offset, ASTContext &Ctx)
Compute the alignment and offset of the base class object given the derived-to-base cast expression a...
static void checkObjCDictionaryLiteral(Sema &S, QualType TargetType, ObjCDictionaryLiteral *DictionaryLiteral)
Check an Objective-C dictionary literal being converted to the given target type.
static void checkArmStreamingBuiltin(Sema &S, CallExpr *TheCall, const FunctionDecl *FD, ArmStreamingType BuiltinType)
static bool isConstantSizeArrayWithMoreThanOneElement(QualType Ty, ASTContext &Context)
static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall, const TargetInfo *AuxTI, unsigned BuiltinID)
BuiltinCpu{Supports|Is} - Handle __builtin_cpu_{supports|is}(char *).
static bool isBlockPointer(Expr *Arg)
static bool isSetterLikeSelector(Selector sel)
Check for a keyword selector that starts with the word 'add' or 'set'.
static bool CheckWasmBuiltinArgIsTable(Sema &S, CallExpr *E, unsigned ArgIndex, QualType &ElTy)
Checks the argument at the given index is a WebAssembly table and if it is, sets ElTy to the element ...
static void adornObjCBoolConversionDiagWithTernaryFixit(Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder)
static bool OpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different overload formats specified ...
static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall, Expr *BlockArg, unsigned NumNonVarArgs)
OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all 'local void*' parameter of passed blo...
static bool BuiltinCommitRWPipe(Sema &S, CallExpr *Call)
static bool IsSameCharType(QualType T1, QualType T2)
bool CheckAllArgsHaveFloatRepresentation(Sema *S, CallExpr *TheCall)
static bool CheckNonNullExpr(Sema &S, const Expr *Expr)
Checks if a the given expression evaluates to null.
static const CXXRecordDecl * getContainedDynamicClass(QualType T, bool &IsContained)
Determine whether the given type is or contains a dynamic class type (e.g., whether it has a vtable).
static Expr * findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner)
Check whether the given argument is a block which captures a variable.
static bool isArgumentExpandedFromMacro(SourceManager &SM, SourceLocation CallLoc, SourceLocation ArgLoc)
Check if the ArgLoc originated from a macro passed to the call at CallLoc.
static ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD)
static const Expr * maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E)
static bool IsStdFunction(const FunctionDecl *FDecl, const char(&Str)[StrLen])
static void AnalyzeAssignment(Sema &S, BinaryOperator *E)
Analyze the given simple or compound assignment for warning-worthy operations.
static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_function_start is a function.
static bool BuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall)
static bool ShouldDiagnoseEmptyStmtBody(const SourceManager &SourceMgr, SourceLocation StmtLoc, const NullStmt *Body)
static std::optional< std::pair< CharUnits, CharUnits > > getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE, bool IsSub, ASTContext &Ctx)
Compute the alignment and offset of a binary additive operator.
static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc)
static ArmSMEState getSMEState(unsigned BuiltinID)
static unsigned changeAbsFunction(unsigned AbsKind, AbsoluteValueKind ValueKind)
static const Expr * ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx)
static void CheckConditionalOperand(Sema &S, Expr *E, QualType T, SourceLocation CC, bool &ICContext)
static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2)
Check if two types are layout-compatible in C++11 sense.
static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool isValidBPFPreserveFieldInfoArg(Expr *Arg)
static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty)
static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall)
static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx)
Returns true if pipe element type is different from the pointer.
static ExprResult PointerAuthBlendDiscriminator(Sema &S, CallExpr *Call)
static const IntegerLiteral * getIntegerLiteral(Expr *E)
static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc)
Analyzes an attempt to assign the given value to a bitfield.
static int classifyConstantValue(Expr *Constant)
static llvm::SmallPtrSet< MemberKind *, 1 > CXXRecordMembersNamed(StringRef Name, Sema &S, QualType Ty)
static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc)
static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType)
static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call)
Returns true if pipe element type is different from the pointer.
static bool checkPointerAuthKey(Sema &S, Expr *&Arg)
static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty)
static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID)
static unsigned getAbsoluteValueFunctionKind(const FunctionDecl *FDecl)
static void diagnoseRetainCycle(Sema &S, Expr *capturer, RetainCycleOwner &owner)
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromLValue(const Expr *E, ASTContext &Ctx)
This helper function takes an lvalue expression and returns the alignment of a VarDecl and a constant...
static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context, bool IsPolyUnsigned, bool IsInt64Long)
getNeonEltType - Return the QualType corresponding to the elements of the vector type specified by th...
static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ArchType > SupportedArchs)
static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< const Expr * > Args, SourceLocation CallSiteLoc)
static unsigned getLargerAbsoluteValueFunction(unsigned AbsFunction)
static bool findRetainCycleOwner(Sema &S, Expr *e, RetainCycleOwner &owner)
static bool hasArmZT0State(const FunctionDecl *FD)
static analyze_format_string::ArgType::MatchKind handleFormatSignedness(analyze_format_string::ArgType::MatchKind Match, DiagnosticsEngine &Diags, SourceLocation Loc)
static bool referToTheSameDecl(const Expr *E1, const Expr *E2)
Check if two expressions refer to the same declaration.
static bool OpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall)
static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall)
Checks that __builtin_{clzg,ctzg} was called with a first argument, which is an unsigned integer,...
static bool requiresParensToAddCast(const Expr *E)
static ExprResult PointerAuthAuthAndResign(Sema &S, CallExpr *Call)
static void checkObjCCollectionLiteralElement(Sema &S, QualType TargetElementType, Expr *Element, unsigned ElementKind)
Check a single element within a collection literal against the target element type.
static bool BuiltinPipePackets(Sema &S, CallExpr *Call)
static bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E, unsigned ArgIndex)
Checks the argument at the given index is an integer.
static bool checkArgCountRange(Sema &S, CallExpr *Call, unsigned MinArgCount, unsigned MaxArgCount)
Checks that a call expression's argument count is in the desired range.
static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty)
static bool ProcessFormatStringLiteral(const Expr *FormatExpr, StringRef &FormatStrRef, size_t &StrLen, ASTContext &Context)
static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount)
Checks that a call expression's argument count is the desired number.
static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall)
Checks that __builtin_popcountg was called with a single argument, which is an unsigned integer.
void SetElementTypeAsReturnType(Sema *S, CallExpr *TheCall, QualType ReturnType)
static void DiagnoseIntInBoolContext(Sema &S, Expr *E)
static std::optional< int > GetNSSetArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool CheckBuiltinTargetNotInUnsupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ObjectFormatType > UnsupportedObjectFormatTypes)
static bool BuiltinAddressof(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_addressof is a glvalue, and set the result type to the correspon...
static CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S)
static OpenCLAccessAttr * getOpenCLArgAccess(const Decl *D)
Returns OpenCL access qual.
static ExprResult PointerAuthSignOrAuth(Sema &S, CallExpr *Call, PointerAuthOpKind OpKind)
static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn)
Check that the user is calling the appropriate va_start builtin for the target and calling convention...
static bool IsEnumConstOrFromMacro(Sema &S, Expr *E)
static const Expr * getStrlenExprArg(const Expr *E)
static bool CheckInvalidVLENandLMUL(const TargetInfo &TI, CallExpr *TheCall, Sema &S, QualType Type, int EGW)
static bool GetMatchingCType(const IdentifierInfo *ArgumentKind, const Expr *TypeExpr, const ASTContext &Ctx, const llvm::DenseMap< Sema::TypeTagMagicValue, Sema::TypeTagData > *MagicValues, bool &FoundWrongKind, Sema::TypeTagData &TypeInfo, bool isConstantEvaluated)
Retrieve the C type corresponding to type tag TypeExpr.
static void checkObjCArrayLiteral(Sema &S, QualType TargetType, ObjCArrayLiteral *ArrayLiteral)
Check an Objective-C array literal being converted to the given target type.
static bool isLayoutCompatibleUnion(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout unions are layout-compatible.
static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str, unsigned &Mask)
DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str, advancing the pointer ov...
static QualType getAbsoluteValueArgumentType(ASTContext &Context, unsigned AbsType)
static void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, const NamedDecl *FDecl, Expr **Args, unsigned NumArgs)
Diagnose use of s directive in an NSString which is being passed as formatting string to formatting m...
static bool isNonNullType(QualType type)
Determine whether the given type has a non-null nullability annotation.
static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A, Sema::FormatArgumentPassingKind B)
static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall)
Check that the first argument to __builtin_annotation is an integer and the second argument is a non-...
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx)
This helper function takes a pointer expression and returns the alignment of a VarDecl and a constant...
static bool IsShiftedByte(llvm::APSInt Value)
static unsigned getBestAbsFunction(ASTContext &Context, QualType ArgType, unsigned AbsFunctionKind)
static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex)
checkBuiltinArgument - Given a call to a builtin function, perform normal type-checking on the given ...
static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E)
Analyze the operands of the given comparison.
static std::optional< int > GetNSMutableArrayArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool isPPC_64Builtin(unsigned BuiltinID)
static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call)
static bool isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE)
Return true if ICE is an implicit argument promotion of an arithmetic type.
static bool isValidBPFPreserveEnumValueArg(Expr *Arg)
static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC, bool IsListInit=false)
AnalyzeImplicitConversions - Find and report any interesting implicit conversions in the given expres...
static bool HasEnumType(Expr *E)
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, unsigned Start, unsigned End)
static bool checkFPMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static bool checkArgCountAtMost(Sema &S, CallExpr *Call, unsigned MaxArgCount)
Checks that a call expression's argument count is at most the desired number.
static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall)
static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam=nullptr)
bool CheckArgsTypesAreCorrect(Sema *S, CallExpr *TheCall, QualType ExpectedType, llvm::function_ref< bool(clang::QualType PassedType)> Check)
This file declares semantic analysis for SYCL constructs.
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Provides definitions for the atomic synchronization scopes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
__DEVICE__ int min(int __a, int __b)
__DEVICE__ int max(int __a, int __b)
__device__ __2f16 float __ockl_bool s
llvm::APInt getValue() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
unsigned getStructNumFields() const
bool isComplexInt() const
ValueKind getKind() const
APSInt & getComplexIntReal()
bool isComplexFloat() const
unsigned getVectorLength() const
APSInt & getComplexIntImag()
APValue & getStructField(unsigned i)
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
APValue & getVectorElt(unsigned I)
bool isAddrLabelDiff() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
const clang::PrintingPolicy & getPrintingPolicy() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getRecordType(const RecordDecl *Decl) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
Builtin::Context & BuiltinInfo
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
const LangOptions & getLangOpts() const
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
CanQualType UnsignedLongTy
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CanQualType OCLClkEventTy
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
CanQualType getNSIntegerType() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
const TargetInfo * getAuxTargetInfo() const
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
CanQualType getNSUIntegerType() const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getQuestionLoc() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
std::unique_ptr< AtomicScopeModel > getScopeModel() const
Get atomic scope model.
SourceLocation getBeginLoc() const LLVM_READONLY
Attr - This represents one attribute.
const char * getSpelling() const
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isLogicalOp(Opcode Opc)
SourceLocation getOperatorLoc() const
SourceLocation getExprLoc() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static bool isAdditiveOp(Opcode Opc)
static bool isEqualityOp(Opcode Opc)
A fixed int type of a specified bitwidth.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
bool capturesVariable(const VarDecl *var) const
const ParmVarDecl * getParamDecl(unsigned i) const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const BlockDecl * getBlockDecl() const
QualType getPointeeType() const
This class is used for builtin types like 'int'.
bool isFloatingPoint() const
bool isSignedInteger() const
bool isUnsignedInteger() const
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
unsigned getAuxBuiltinID(unsigned ID) const
Return real builtin ID (i.e.
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
A call to an overloaded operator written using operator syntax.
SourceLocation getExprLoc() const LLVM_READONLY
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a list-initialization with parenthesis.
ArrayRef< Expr * > getInitExprs()
Represents a C++ struct/union/class.
bool isStandardLayout() const
Determine whether this class is standard-layout per C++ [class]p7.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
base_class_iterator bases_begin()
bool isDynamicClass() const
CXXRecordDecl * getDefinition() const
Represents a C++ nested-name-specifier or a global scope specifier.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr ** getArgs()
Retrieve the call arguments.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isCallToStdMove() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
SourceLocation getRParenLoc() const
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
static CharSourceRange getTokenRange(SourceRange R)
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
bool isOne() const
isOne - Test whether the quantity equals one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
ConditionalOperator - The ?: ternary operator.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
llvm::APInt getSize() const
Return the constant array size as an APInt.
Represents a concrete matrix type with constant number of rows and columns.
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Expr * getOperand() const
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
bool isInvalidDecl() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
SourceLocation getLocation() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getBeginLoc() const LLVM_READONLY
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
RAII class that determines when any errors have occurred between the time the instance was created an...
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Concrete class used by the front-end to report problems and issues.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
An instance of this object exists for each enum constant that is defined.
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
bool isComplete() const
Returns true if this can be considered a complete type.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EvaluatedExprVisitor - This class visits 'Expr *'s.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
@ SE_NoSideEffects
Strictly evaluate the expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string poin...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed poi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_NotNull
Expression is not a Null pointer constant.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
void EvaluateForOverflow(const ASTContext &Ctx) const
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
llvm::APFloat getValue() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a function declaration or definition.
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool hasCXXExplicitFunctionObjectParameter() const
QualType getReturnType() const
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
ArrayRef< ParmVarDecl * > parameters() const
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
const ParmVarDecl * getParamDecl(unsigned i) const
Represents a prototype with parameter type info, e.g.
ArrayRef< QualType > getParamTypes() const
unsigned getNumParams() const
QualType getParamType(unsigned i) const
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
FunctionType - C99 6.7.5.3 - Function Declarators.
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
QualType getReturnType() const
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Describes an C or C++ initializer list.
ArrayRef< Expr * > inits()
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
StrictFlexArraysLevelKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
static StringRef getImmediateMacroNameForDiagnostics(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isValidElementType(QualType T)
Valid elements types are the following:
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
@ ClassId_NSMutableOrderedSet
@ ClassId_NSMutableDictionary
NSSetMethodKind
Enumerates the NSMutableSet/NSOrderedSet methods used to apply some checks.
@ NSOrderedSet_setObjectAtIndex
@ NSOrderedSet_replaceObjectAtIndexWithObject
@ NSOrderedSet_setObjectAtIndexedSubscript
@ NSOrderedSet_insertObjectAtIndex
NSDictionaryMethodKind
Enumerates the NSDictionary/NSMutableDictionary methods used to generate literals and to apply some c...
@ NSMutableDict_setValueForKey
@ NSMutableDict_setObjectForKey
@ NSMutableDict_setObjectForKeyedSubscript
NSArrayMethodKind
Enumerates the NSArray/NSMutableArray methods used to generate literals and to apply some checks.
@ NSMutableArr_setObjectAtIndexedSubscript
@ NSMutableArr_insertObjectAtIndex
@ NSMutableArr_replaceObjectAtIndex
This represents a decl that may have a name.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
Flags to identify the types for overloaded Neon builtins.
EltType getEltType() const
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NullStmt - This is the null statement ";": C99 6.8.3p3.
bool hasLeadingEmptyMacro() const
SourceLocation getSemiLoc() const
OpenMP 5.0 [2.1.5, Array Sections].
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Expr * getLowerBound()
Get lower bound of array section.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Represents an ObjC class declaration.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
SourceLocation getSuperLoc() const
Retrieve the location of the 'super' keyword for a class or instance message to 'super',...
Selector getSelector() const
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
@ SuperInstance
The receiver is the instance of the superclass object.
@ Instance
The receiver is an object instance.
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
const ObjCMethodDecl * getMethodDecl() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver.
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
ArrayRef< ParmVarDecl * > parameters() const
Represents a pointer to an Objective C object.
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
Represents one property declaration in an Objective-C interface.
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCPropertyDecl * getExplicitProperty() const
const Expr * getBase() const
bool isImplicitProperty() const
SourceLocation getLocation() const
bool isSuperReceiver() const
ObjCStringLiteral, used for Objective-C string literals i.e.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
QualType getElementType() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
PrimitiveDefaultInitializeKind
QualType withoutLocalFastQualifiers() const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool isConstant(const ASTContext &Ctx) const
QualType withVolatile() const
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void removeLocalVolatile()
bool isConstQualified() const
Determine whether this type is const-qualified.
const Type * getTypePtrOrNull() const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasUnaligned() const
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Scope - A scope is a transient data structure that is used while parsing the program.
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
@ SEHExceptScope
This scope corresponds to an SEH except.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
unsigned getNumArgs() const
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
@ KernelCallVariadicFunction
static bool isSyclType(QualType Ty, SYCLTypeAttr::SYCLType TypeName)
Check whether Ty corresponds to a SYCL type of name TypeName.
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID, DeviceDiagnosticReason Reason=DeviceDiagnosticReason::Sycl|DeviceDiagnosticReason::Esimd)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
Sema - This implements semantic analysis and AST building for C.
bool IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base, const TypeSourceInfo *Derived)
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
OpenCLOptions & getOpenCLOptions()
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupAnyName
Look up any declaration with any name.
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
bool FormatStringHasSArg(const StringLiteral *FExpr)
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, bool IsVariadic, FormatStringInfo *FSI)
Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo parameter with the Format...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void RefersToMemberWithReducedAlignment(Expr *E, llvm::function_ref< void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> Action)
This function calls Action when it determines that E designates a misaligned member due to the packed...
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
static FormatStringType GetFormatStringType(const FormatAttr *Format)
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
Scope * getCurScope() const
Retrieve the parser's current scope.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool BuiltinVectorToScalarMath(CallExpr *TheCall)
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
bool CheckHLSLBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall)
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool IsLayoutCompatible(QualType T1, QualType T2) const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange)
CheckCastAlign - Implements -Wcast-align, which warns when a pointer cast increases the alignment req...
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
const LangOptions & getLangOpts() const
static const uint64_t MaximumAlignment
ExprResult ConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
ConvertVectorExpr - Handle __builtin_convertvector.
bool checkConstantPointerAuthKey(Expr *keyExpr, unsigned &key)
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx)
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
void popCodeSynthesisContext()
void DiagnoseMisalignedMembers()
Diagnoses the current set of gathered accesses.
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
std::pair< const IdentifierInfo *, uint64_t > TypeTagMagicValue
A pair of ArgumentKind identifier and magic value.
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
Determine if type T is a valid subject for a nonnull and similar attributes.
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
bool BuiltinVectorMath(CallExpr *TheCall, QualType &Res)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
FormatArgumentPassingKind
@ Compatible
Compatible - the types are compatible according to the standard.
SourceManager & getSourceManager() const
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
bool isConstantEvaluatedContext() const
ASTContext & getASTContext() const
ExprResult BuiltinShuffleVector(CallExpr *TheCall)
BuiltinShuffleVector - Handle __builtin_shufflevector.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceManager & SourceMgr
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
DiagnosticsEngine & Diags
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder=AtomicArgumentOrder::API)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
DiagnosticsEngine & getDiagnostics() const
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getLength() const
StringLiteralKind getKind() const
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
unsigned getByteLength() const
StringRef getString() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCharByteWidth() const
Exposes information about the current target.
virtual bool validatePointerAuthKey(const llvm::APSInt &value) const
Determine whether the given pointer-authentication key is valid.
virtual bool supportsCpuSupports() const
virtual bool validateCpuIs(StringRef Name) const
virtual bool supportsCpuInit() const
IntType getInt64Type() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
IntType getSizeType() const
const llvm::fltSemantics & getLongDoubleFormat() const
IntType getIntPtrType() const
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool validateCpuSupports(StringRef Name) const
virtual bool supportsCpuIs() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual bool checkArithmeticFenceSupported() const
Controls if __arithmetic_fence is supported in the targeted backend.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool hasSjLjLowering() const
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
A template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Represents a template argument.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Type
The template argument is a type.
ArgKind getKind() const
Return the kind of stored template argument.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getBeginLoc() const
Get the begin source location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isFloat16Type() const
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isFunctionPointerType() const
bool isPointerType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isLValueReferenceType() const
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFloat32Type() const
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isBFloat16Type() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isStructureOrClassType() const
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isSizelessVectorType() const
Returns true for all scalable vector types.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
SourceLocation getBeginLoc() const LLVM_READONLY
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Represents a GCC generic vector type.
unsigned getNumElements() const
WhileStmt - This represents a 'while' stmt.
Defines the clang::TargetInfo interface.
__inline void unsigned int _2
bool evaluateRequiredTargetFeatures(llvm::StringRef RequiredFatures, const llvm::StringMap< bool > &TargetFetureMap)
Returns true if the required target features of a builtin function are enabled.
const AstTypeMatcher< PointerType > pointerType
Matches pointer types, but does not match Objective-C object pointer types.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
ComparisonResult
Indicates the result of a tentative comparison.
uint32_t Literal
Literals are represented as positive integers.
static constexpr Variable var(Literal L)
Returns the variable of L.
uint32_t Variable
Boolean variables are represented as positive integers.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
@ After
Like System, but searched after the system directories.
@ FixIt
Parse and apply any fixits to the source.
bool GT(InterpState &S, CodePtr OpPC)
bool Call(InterpState &S, CodePtr OpPC, const Function *Func, uint32_t VarArgSize)
bool NE(InterpState &S, CodePtr OpPC)
bool LE(InterpState &S, CodePtr OpPC)
bool InRange(InterpState &S, CodePtr OpPC)
bool Load(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
bool EQ(InterpState &S, CodePtr OpPC)
bool GE(InterpState &S, CodePtr OpPC)
std::string toString(const til::SExpr *E)
The JSON file list parser is used to communicate input to InstallAPI.
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
@ NonNull
Values of this type can never be null.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
LangAS
Defines the address space values used by the address space qualifier of QualType.
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
CastKind
CastKind - The kind of operation required for a conversion.
ActionResult< ParsedType > TypeResult
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
for(const auto &A :T->param_types())
const FunctionProtoType * T
raw_ostream & Indent(raw_ostream &Out, const unsigned int Space, bool IsDot)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecVector
is AltiVec vector
@ Generic
not a target-specific vector type
U cast(CodeGen::Address addr)
@ Other
Other implicit parameter.
float __ovld __cnfn distance(float, float)
Returns the distance between p0 and p1.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Extra information about a function prototype.
unsigned AArch64SMEAttributes
Describes how types, statements, expressions, and declarations should be printed.
unsigned AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g.,...
unsigned Indentation
The number of spaces to use to indent each line.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
unsigned NumCallArgs
The number of expressions in CallArgs.
const Expr *const * CallArgs
The list of argument expressions in a synthesized call.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.